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