001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.usersadmin.lar;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.util.MapUtil;
019    import com.liferay.portal.kernel.xml.Element;
020    import com.liferay.portal.model.Address;
021    import com.liferay.portal.model.EmailAddress;
022    import com.liferay.portal.model.Group;
023    import com.liferay.portal.model.OrgLabor;
024    import com.liferay.portal.model.Organization;
025    import com.liferay.portal.model.OrganizationConstants;
026    import com.liferay.portal.model.PasswordPolicy;
027    import com.liferay.portal.model.PasswordPolicyRel;
028    import com.liferay.portal.model.Phone;
029    import com.liferay.portal.model.Website;
030    import com.liferay.portal.service.AddressLocalServiceUtil;
031    import com.liferay.portal.service.EmailAddressLocalServiceUtil;
032    import com.liferay.portal.service.GroupLocalServiceUtil;
033    import com.liferay.portal.service.OrgLaborLocalServiceUtil;
034    import com.liferay.portal.service.OrganizationLocalServiceUtil;
035    import com.liferay.portal.service.PasswordPolicyLocalServiceUtil;
036    import com.liferay.portal.service.PasswordPolicyRelLocalServiceUtil;
037    import com.liferay.portal.service.PhoneLocalServiceUtil;
038    import com.liferay.portal.service.ServiceContext;
039    import com.liferay.portal.service.WebsiteLocalServiceUtil;
040    import com.liferay.portlet.exportimport.lar.BaseStagedModelDataHandler;
041    import com.liferay.portlet.exportimport.lar.ExportImportPathUtil;
042    import com.liferay.portlet.exportimport.lar.PortletDataContext;
043    import com.liferay.portlet.exportimport.lar.StagedModelDataHandlerUtil;
044    import com.liferay.portlet.usersadmin.util.UsersAdminUtil;
045    
046    import java.util.ArrayList;
047    import java.util.LinkedList;
048    import java.util.List;
049    import java.util.Map;
050    import java.util.Queue;
051    
052    /**
053     * @author David Mendez Gonzalez
054     */
055    public class OrganizationStagedModelDataHandler
056            extends BaseStagedModelDataHandler<Organization> {
057    
058            public static final String[] CLASS_NAMES = {Organization.class.getName()};
059    
060            @Override
061            public void deleteStagedModel(Organization organization)
062                    throws PortalException {
063    
064                    OrganizationLocalServiceUtil.deleteOrganization(organization);
065            }
066    
067            @Override
068            public void deleteStagedModel(
069                            String uuid, long groupId, String className, String extraData)
070                    throws PortalException {
071    
072                    Group group = GroupLocalServiceUtil.getGroup(groupId);
073    
074                    Organization organization =
075                            OrganizationLocalServiceUtil.fetchOrganizationByUuidAndCompanyId(
076                                    uuid, group.getCompanyId());
077    
078                    if (organization != null) {
079                            deleteStagedModel(organization);
080                    }
081            }
082    
083            @Override
084            public List<Organization> fetchStagedModelsByUuidAndCompanyId(
085                    String uuid, long companyId) {
086    
087                    List<Organization> organizations = new ArrayList<>();
088    
089                    organizations.add(
090                            OrganizationLocalServiceUtil.fetchOrganizationByUuidAndCompanyId(
091                                    uuid, companyId));
092    
093                    return organizations;
094            }
095    
096            @Override
097            public String[] getClassNames() {
098                    return CLASS_NAMES;
099            }
100    
101            @Override
102            public String getDisplayName(Organization organization) {
103                    return organization.getName();
104            }
105    
106            @Override
107            protected void doExportStagedModel(
108                            PortletDataContext portletDataContext, Organization organization)
109                    throws Exception {
110    
111                    Queue<Organization> organizations = new LinkedList<>();
112    
113                    organizations.add(organization);
114    
115                    while (!organizations.isEmpty()) {
116                            Organization exportedOrganization = organizations.remove();
117    
118                            if (organization.getParentOrganizationId() !=
119                                            OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID) {
120    
121                                    StagedModelDataHandlerUtil.exportReferenceStagedModel(
122                                            portletDataContext, organization,
123                                            organization.getParentOrganization(),
124                                            PortletDataContext.REFERENCE_TYPE_PARENT);
125                            }
126    
127                            exportAddresses(portletDataContext, exportedOrganization);
128                            exportEmailAddresses(portletDataContext, exportedOrganization);
129                            exportOrgLabors(portletDataContext, exportedOrganization);
130                            exportPasswordPolicyRel(portletDataContext, exportedOrganization);
131                            exportPhones(portletDataContext, exportedOrganization);
132                            exportWebsites(portletDataContext, exportedOrganization);
133    
134                            Element organizationElement =
135                                    portletDataContext.getExportDataElement(exportedOrganization);
136    
137                            portletDataContext.addClassedModel(
138                                    organizationElement,
139                                    ExportImportPathUtil.getModelPath(exportedOrganization),
140                                    exportedOrganization);
141    
142                            organizations.addAll(exportedOrganization.getSuborganizations());
143                    }
144            }
145    
146            @Override
147            protected void doImportStagedModel(
148                            PortletDataContext portletDataContext, Organization organization)
149                    throws Exception {
150    
151                    long userId = portletDataContext.getUserId(organization.getUserUuid());
152    
153                    Map<Long, Long> organizationIds =
154                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
155                                    Organization.class);
156    
157                    long parentOrganizationId = MapUtil.getLong(
158                            organizationIds, organization.getParentOrganizationId(),
159                            organization.getParentOrganizationId());
160    
161                    ServiceContext serviceContext = portletDataContext.createServiceContext(
162                            organization);
163    
164                    serviceContext.setUserId(userId);
165    
166                    Organization existingOrganization =
167                            OrganizationLocalServiceUtil.fetchOrganizationByUuidAndCompanyId(
168                                    organization.getUuid(), portletDataContext.getGroupId());
169    
170                    if (existingOrganization == null) {
171                            existingOrganization =
172                                    OrganizationLocalServiceUtil.fetchOrganization(
173                                            portletDataContext.getCompanyId(), organization.getName());
174                    }
175    
176                    Organization importedOrganization = null;
177    
178                    if (existingOrganization == null) {
179                            serviceContext.setUuid(organization.getUuid());
180    
181                            importedOrganization = OrganizationLocalServiceUtil.addOrganization(
182                                    userId, parentOrganizationId, organization.getName(),
183                                    organization.getType(), organization.getRegionId(),
184                                    organization.getCountryId(), organization.getStatusId(),
185                                    organization.getComments(), false, serviceContext);
186                    }
187                    else {
188                            importedOrganization =
189                                    OrganizationLocalServiceUtil.updateOrganization(
190                                            portletDataContext.getCompanyId(),
191                                            existingOrganization.getOrganizationId(),
192                                            parentOrganizationId, organization.getName(),
193                                            organization.getType(), organization.getRegionId(),
194                                            organization.getCountryId(), organization.getStatusId(),
195                                            organization.getComments(), true, null, false,
196                                            serviceContext);
197                    }
198    
199                    importAddresses(portletDataContext, organization, importedOrganization);
200                    importEmailAddresses(
201                            portletDataContext, organization, importedOrganization);
202                    importOrgLabors(portletDataContext, organization, importedOrganization);
203                    importPasswordPolicyRel(
204                            portletDataContext, organization, importedOrganization);
205                    importPhones(portletDataContext, organization, importedOrganization);
206                    importWebsites(portletDataContext, organization, importedOrganization);
207    
208                    portletDataContext.importClassedModel(
209                            organization, importedOrganization);
210            }
211    
212            protected void exportAddresses(
213                            PortletDataContext portletDataContext, Organization organization)
214                    throws PortalException {
215    
216                    List<Address> addresses = AddressLocalServiceUtil.getAddresses(
217                            organization.getCompanyId(), organization.getModelClassName(),
218                            organization.getOrganizationId());
219    
220                    for (Address address : addresses) {
221                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
222                                    portletDataContext, organization, address,
223                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
224                    }
225            }
226    
227            protected void exportEmailAddresses(
228                            PortletDataContext portletDataContext, Organization organization)
229                    throws PortalException {
230    
231                    List<EmailAddress> emailAddresses =
232                            EmailAddressLocalServiceUtil.getEmailAddresses(
233                                    organization.getCompanyId(), organization.getModelClassName(),
234                                    organization.getOrganizationId());
235    
236                    for (EmailAddress emailAddress : emailAddresses) {
237                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
238                                    portletDataContext, organization, emailAddress,
239                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
240                    }
241            }
242    
243            protected void exportOrgLabors(
244                    PortletDataContext portletDataContext, Organization organization) {
245    
246                    List<OrgLabor> orgLabors = OrgLaborLocalServiceUtil.getOrgLabors(
247                            organization.getOrganizationId());
248    
249                    String path = ExportImportPathUtil.getModelPath(
250                            organization, OrgLabor.class.getSimpleName());
251    
252                    portletDataContext.addZipEntry(path, orgLabors);
253            }
254    
255            protected void exportPasswordPolicyRel(
256                            PortletDataContext portletDataContext, Organization organization)
257                    throws PortalException {
258    
259                    PasswordPolicyRel passwordPolicyRel =
260                            PasswordPolicyRelLocalServiceUtil.fetchPasswordPolicyRel(
261                                    Organization.class.getName(), organization.getOrganizationId());
262    
263                    if (passwordPolicyRel == null) {
264                            return;
265                    }
266    
267                    PasswordPolicy passwordPolicy =
268                            PasswordPolicyLocalServiceUtil.getPasswordPolicy(
269                                    passwordPolicyRel.getPasswordPolicyId());
270    
271                    StagedModelDataHandlerUtil.exportReferenceStagedModel(
272                            portletDataContext, organization, passwordPolicy,
273                            PortletDataContext.REFERENCE_TYPE_STRONG);
274            }
275    
276            protected void exportPhones(
277                            PortletDataContext portletDataContext, Organization organization)
278                    throws PortalException {
279    
280                    List<Phone> phones = PhoneLocalServiceUtil.getPhones(
281                            organization.getCompanyId(), organization.getModelClassName(),
282                            organization.getOrganizationId());
283    
284                    for (Phone phone : phones) {
285                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
286                                    portletDataContext, organization, phone,
287                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
288                    }
289            }
290    
291            protected void exportWebsites(
292                            PortletDataContext portletDataContext, Organization organization)
293                    throws PortalException {
294    
295                    List<Website> websites = WebsiteLocalServiceUtil.getWebsites(
296                            organization.getCompanyId(), organization.getModelClassName(),
297                            organization.getOrganizationId());
298    
299                    for (Website website : websites) {
300                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
301                                    portletDataContext, organization, website,
302                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
303                    }
304            }
305    
306            protected void importAddresses(
307                            PortletDataContext portletDataContext, Organization organization,
308                            Organization importedOrganization)
309                    throws PortalException {
310    
311                    List<Element> addressElements =
312                            portletDataContext.getReferenceDataElements(
313                                    organization, Address.class);
314    
315                    List<Address> addresses = new ArrayList<>(addressElements.size());
316    
317                    for (Element addressElement : addressElements) {
318                            String addressPath = addressElement.attributeValue("path");
319    
320                            Address address = (Address)portletDataContext.getZipEntryAsObject(
321                                    addressPath);
322    
323                            address.setClassPK(importedOrganization.getOrganizationId());
324    
325                            StagedModelDataHandlerUtil.importStagedModel(
326                                    portletDataContext, address);
327    
328                            Map<Long, Long> addressIds =
329                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
330                                            Address.class);
331    
332                            long addressId = addressIds.get(address.getPrimaryKey());
333    
334                            address.setAddressId(addressId);
335    
336                            addresses.add(address);
337                    }
338    
339                    UsersAdminUtil.updateAddresses(
340                            Organization.class.getName(),
341                            importedOrganization.getOrganizationId(), addresses);
342            }
343    
344            protected void importEmailAddresses(
345                            PortletDataContext portletDataContext, Organization organization,
346                            Organization importedOrganization)
347                    throws PortalException {
348    
349                    List<Element> emailAddressElements =
350                            portletDataContext.getReferenceDataElements(
351                                    organization, EmailAddress.class);
352    
353                    List<EmailAddress> emailAddresses = new ArrayList<>(
354                            emailAddressElements.size());
355    
356                    for (Element emailAddressElement : emailAddressElements) {
357                            String emailAddressPath = emailAddressElement.attributeValue(
358                                    "path");
359    
360                            EmailAddress emailAddress =
361                                    (EmailAddress)portletDataContext.getZipEntryAsObject(
362                                            emailAddressPath);
363    
364                            emailAddress.setClassPK(importedOrganization.getOrganizationId());
365    
366                            StagedModelDataHandlerUtil.importStagedModel(
367                                    portletDataContext, emailAddress);
368    
369                            Map<Long, Long> emailAddressIds =
370                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
371                                            EmailAddress.class);
372    
373                            long emailAddressId = emailAddressIds.get(
374                                    emailAddress.getPrimaryKey());
375    
376                            emailAddress.setEmailAddressId(emailAddressId);
377    
378                            emailAddresses.add(emailAddress);
379                    }
380    
381                    UsersAdminUtil.updateEmailAddresses(
382                            Organization.class.getName(),
383                            importedOrganization.getOrganizationId(), emailAddresses);
384            }
385    
386            protected void importOrgLabors(
387                            PortletDataContext portletDataContext, Organization organization,
388                            Organization importedOrganization)
389                    throws PortalException {
390    
391                    String path = ExportImportPathUtil.getModelPath(
392                            organization, OrgLabor.class.getSimpleName());
393    
394                    List<OrgLabor> orgLabors =
395                            (List<OrgLabor>)portletDataContext.getZipEntryAsObject(path);
396    
397                    for (OrgLabor orgLabor : orgLabors) {
398                            orgLabor.setOrgLaborId(0);
399                    }
400    
401                    UsersAdminUtil.updateOrgLabors(
402                            importedOrganization.getOrganizationId(), orgLabors);
403            }
404    
405            protected void importPasswordPolicyRel(
406                            PortletDataContext portletDataContext, Organization organization,
407                            Organization importedOrganization)
408                    throws PortalException {
409    
410                    List<Element> passwordPolicyElements =
411                            portletDataContext.getReferenceDataElements(
412                                    organization, PasswordPolicy.class);
413    
414                    if (passwordPolicyElements.isEmpty()) {
415                            return;
416                    }
417    
418                    Element passwordPolicyElement = passwordPolicyElements.get(0);
419    
420                    String passwordPolicyPath = passwordPolicyElement.attributeValue(
421                            "path");
422    
423                    PasswordPolicy passwordPolicy =
424                            (PasswordPolicy)portletDataContext.getZipEntryAsObject(
425                                    passwordPolicyPath);
426    
427                    StagedModelDataHandlerUtil.importStagedModel(
428                            portletDataContext, passwordPolicy);
429    
430                    Map<Long, Long> passwordPolicyIds =
431                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
432                                    PasswordPolicy.class);
433    
434                    long passwordPolicyId = passwordPolicyIds.get(
435                            passwordPolicy.getPrimaryKey());
436    
437                    OrganizationLocalServiceUtil.addPasswordPolicyOrganizations(
438                            passwordPolicyId,
439                            new long[] {importedOrganization.getOrganizationId()});
440            }
441    
442            protected void importPhones(
443                            PortletDataContext portletDataContext, Organization organization,
444                            Organization importedOrganization)
445                    throws PortalException {
446    
447                    List<Element> phoneElements =
448                            portletDataContext.getReferenceDataElements(
449                                    organization, Phone.class);
450    
451                    List<Phone> phones = new ArrayList<>(phoneElements.size());
452    
453                    for (Element phoneElement : phoneElements) {
454                            String phonePath = phoneElement.attributeValue("path");
455    
456                            Phone phone = (Phone)portletDataContext.getZipEntryAsObject
457                                    (phonePath);
458    
459                            phone.setClassPK(importedOrganization.getOrganizationId());
460    
461                            StagedModelDataHandlerUtil.importStagedModel(
462                                    portletDataContext, phone);
463    
464                            Map<Long, Long> phoneIds =
465                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
466                                            Phone.class);
467    
468                            long phoneId = phoneIds.get(phone.getPrimaryKey());
469    
470                            phone.setPhoneId(phoneId);
471    
472                            phones.add(phone);
473                    }
474    
475                    UsersAdminUtil.updatePhones(
476                            Organization.class.getName(),
477                            importedOrganization.getOrganizationId(), phones);
478            }
479    
480            @Override
481            protected void importReferenceStagedModels(
482                    PortletDataContext portletDataContext, Organization organization) {
483            }
484    
485            protected void importWebsites(
486                            PortletDataContext portletDataContext, Organization organization,
487                            Organization importedOrganization)
488                    throws PortalException {
489    
490                    List<Element> websiteElements =
491                            portletDataContext.getReferenceDataElements(
492                                    organization, Website.class);
493    
494                    List<Website> websites = new ArrayList<>(websiteElements.size());
495    
496                    for (Element websiteElement : websiteElements) {
497                            String websitePath = websiteElement.attributeValue("path");
498    
499                            Website website = (Website)portletDataContext.getZipEntryAsObject(
500                                    websitePath);
501    
502                            website.setClassPK(importedOrganization.getOrganizationId());
503    
504                            StagedModelDataHandlerUtil.importStagedModel(
505                                    portletDataContext, website);
506    
507                            Map<Long, Long> websiteIds =
508                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
509                                            Website.class);
510    
511                            long websiteId = websiteIds.get(website.getPrimaryKey());
512    
513                            website.setWebsiteId(websiteId);
514    
515                            websites.add(website);
516                    }
517    
518                    UsersAdminUtil.updateWebsites(
519                            Organization.class.getName(),
520                            importedOrganization.getOrganizationId(), websites);
521            }
522    
523    }