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