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);
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);
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            }
208    
209            protected void exportAddresses(
210                            PortletDataContext portletDataContext, Organization organization,
211                            Element organizationElement)
212                    throws PortalException, SystemException {
213    
214                    List<Address> addresses = AddressLocalServiceUtil.getAddresses(
215                            organization.getCompanyId(), organization.getModelClassName(),
216                            organization.getOrganizationId());
217    
218                    for (Address address : addresses) {
219                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
220                                    portletDataContext, organization, address,
221                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
222                    }
223            }
224    
225            protected void exportEmailAddresses(
226                            PortletDataContext portletDataContext, Organization organization,
227                            Element organizationElement)
228                    throws PortalException, SystemException {
229    
230                    List<EmailAddress> emailAddresses =
231                            EmailAddressLocalServiceUtil.getEmailAddresses(
232                                    organization.getCompanyId(), organization.getModelClassName(),
233                                    organization.getOrganizationId());
234    
235                    for (EmailAddress emailAddress : emailAddresses) {
236                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
237                                    portletDataContext, organization, emailAddress,
238                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
239                    }
240            }
241    
242            protected void exportOrgLabors(
243                            PortletDataContext portletDataContext, Organization organization)
244                    throws SystemException {
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                            Element organizationElement)
258                    throws PortalException, SystemException {
259    
260                    PasswordPolicyRel passwordPolicyRel =
261                            PasswordPolicyRelLocalServiceUtil.fetchPasswordPolicyRel(
262                                    Organization.class.getName(), organization.getOrganizationId());
263    
264                    if (passwordPolicyRel == null) {
265                            return;
266                    }
267    
268                    PasswordPolicy passwordPolicy =
269                            PasswordPolicyLocalServiceUtil.getPasswordPolicy(
270                                    passwordPolicyRel.getPasswordPolicyId());
271    
272                    StagedModelDataHandlerUtil.exportReferenceStagedModel(
273                            portletDataContext, organization, passwordPolicy,
274                            PortletDataContext.REFERENCE_TYPE_STRONG);
275            }
276    
277            protected void exportPhones(
278                            PortletDataContext portletDataContext, Organization organization,
279                            Element organizationElement)
280                    throws PortalException, SystemException {
281    
282                    List<Phone> phones = PhoneLocalServiceUtil.getPhones(
283                            organization.getCompanyId(), organization.getModelClassName(),
284                            organization.getOrganizationId());
285    
286                    for (Phone phone : phones) {
287                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
288                                    portletDataContext, organization, phone,
289                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
290                    }
291            }
292    
293            protected void exportWebsites(
294                            PortletDataContext portletDataContext, Organization organization,
295                            Element organizationElement)
296                    throws PortalException, SystemException {
297    
298                    List<Website> websites = WebsiteLocalServiceUtil.getWebsites(
299                            organization.getCompanyId(), organization.getModelClassName(),
300                            organization.getOrganizationId());
301    
302                    for (Website website : websites) {
303                            StagedModelDataHandlerUtil.exportReferenceStagedModel(
304                                    portletDataContext, organization, website,
305                                    PortletDataContext.REFERENCE_TYPE_EMBEDDED);
306                    }
307            }
308    
309            protected void importAddresses(
310                            PortletDataContext portletDataContext, Organization organization,
311                            Organization importedOrganization)
312                    throws PortalException, SystemException {
313    
314                    List<Element> addressElements =
315                            portletDataContext.getReferenceDataElements(
316                                    organization, Address.class);
317    
318                    List<Address> addresses = new ArrayList<Address>(
319                            addressElements.size());
320    
321                    for (Element addressElement : addressElements) {
322                            String addressPath = addressElement.attributeValue("path");
323    
324                            Address address = (Address)portletDataContext.getZipEntryAsObject(
325                                    addressPath);
326    
327                            address.setClassPK(importedOrganization.getOrganizationId());
328    
329                            StagedModelDataHandlerUtil.importReferenceStagedModel(
330                                    portletDataContext, address);
331    
332                            Map<Long, Long> addressIds =
333                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
334                                            Address.class);
335    
336                            long addressId = addressIds.get(address.getPrimaryKey());
337    
338                            address.setAddressId(addressId);
339    
340                            addresses.add(address);
341                    }
342    
343                    UsersAdminUtil.updateAddresses(
344                            Organization.class.getName(),
345                            importedOrganization.getOrganizationId(), addresses);
346            }
347    
348            protected void importEmailAddresses(
349                            PortletDataContext portletDataContext, Organization organization,
350                            Organization importedOrganization)
351                    throws PortalException, SystemException {
352    
353                    List<Element> emailAddressElements =
354                            portletDataContext.getReferenceDataElements(
355                                    organization, EmailAddress.class);
356    
357                    List<EmailAddress> emailAddresses = new ArrayList<EmailAddress>(
358                            emailAddressElements.size());
359    
360                    for (Element emailAddressElement : emailAddressElements) {
361                            String emailAddressPath = emailAddressElement.attributeValue(
362                                    "path");
363    
364                            EmailAddress emailAddress =
365                                    (EmailAddress)portletDataContext.getZipEntryAsObject(
366                                            emailAddressPath);
367    
368                            emailAddress.setClassPK(importedOrganization.getOrganizationId());
369    
370                            StagedModelDataHandlerUtil.importReferenceStagedModel(
371                                    portletDataContext, emailAddress);
372    
373                            Map<Long, Long> emailAddressIds =
374                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
375                                            EmailAddress.class);
376    
377                            long emailAddressId = emailAddressIds.get(
378                                    emailAddress.getPrimaryKey());
379    
380                            emailAddress.setEmailAddressId(emailAddressId);
381    
382                            emailAddresses.add(emailAddress);
383                    }
384    
385                    UsersAdminUtil.updateEmailAddresses(
386                            Organization.class.getName(),
387                            importedOrganization.getOrganizationId(), emailAddresses);
388            }
389    
390            protected void importOrgLabors(
391                            PortletDataContext portletDataContext, Organization organization,
392                            Organization importedOrganization)
393                    throws PortalException, SystemException {
394    
395                    String path = ExportImportPathUtil.getModelPath(
396                            organization, OrgLabor.class.getSimpleName());
397    
398                    List<OrgLabor> orgLabors =
399                            (List<OrgLabor>)portletDataContext.getZipEntryAsObject(path);
400    
401                    for (OrgLabor orgLabor : orgLabors) {
402                            orgLabor.setOrgLaborId(0);
403                    }
404    
405                    UsersAdminUtil.updateOrgLabors(
406                            importedOrganization.getOrganizationId(), orgLabors);
407            }
408    
409            protected void importPasswordPolicyRel(
410                            PortletDataContext portletDataContext, Organization organization,
411                            Organization importedOrganization)
412                    throws PortalException, SystemException {
413    
414                    List<Element> passwordPolicyElements =
415                            portletDataContext.getReferenceDataElements(
416                                    organization, PasswordPolicy.class);
417    
418                    if (passwordPolicyElements.isEmpty()) {
419                            return;
420                    }
421    
422                    Element passwordPolicyElement = passwordPolicyElements.get(0);
423    
424                    String passwordPolicyPath = passwordPolicyElement.attributeValue(
425                            "path");
426    
427                    PasswordPolicy passwordPolicy =
428                            (PasswordPolicy)portletDataContext.getZipEntryAsObject(
429                                    passwordPolicyPath);
430    
431                    StagedModelDataHandlerUtil.importReferenceStagedModel(
432                            portletDataContext, passwordPolicy);
433    
434                    Map<Long, Long> passwordPolicyIds =
435                            (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
436                                    PasswordPolicy.class);
437    
438                    long passwordPolicyId = passwordPolicyIds.get(
439                            passwordPolicy.getPrimaryKey());
440    
441                    OrganizationLocalServiceUtil.addPasswordPolicyOrganizations(
442                            passwordPolicyId,
443                            new long[] {importedOrganization.getOrganizationId()});
444            }
445    
446            protected void importPhones(
447                            PortletDataContext portletDataContext, Organization organization,
448                            Organization importedOrganization)
449                    throws PortalException, SystemException {
450    
451                    List<Element> phoneElements =
452                            portletDataContext.getReferenceDataElements(
453                                    organization, Phone.class);
454    
455                    List<Phone> phones = new ArrayList<Phone>(phoneElements.size());
456    
457                    for (Element phoneElement : phoneElements) {
458                            String phonePath = phoneElement.attributeValue("path");
459    
460                            Phone phone = (Phone)portletDataContext.getZipEntryAsObject
461                                    (phonePath);
462    
463                            phone.setClassPK(importedOrganization.getOrganizationId());
464    
465                            StagedModelDataHandlerUtil.importReferenceStagedModel(
466                                    portletDataContext, phone);
467    
468                            Map<Long, Long> phoneIds =
469                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
470                                            Phone.class);
471    
472                            long phoneId = phoneIds.get(phone.getPrimaryKey());
473    
474                            phone.setPhoneId(phoneId);
475    
476                            phones.add(phone);
477                    }
478    
479                    UsersAdminUtil.updatePhones(
480                            Organization.class.getName(),
481                            importedOrganization.getOrganizationId(), phones);
482            }
483    
484            protected void importWebsites(
485                            PortletDataContext portletDataContext, Organization organization,
486                            Organization importedOrganization)
487                    throws PortalException, SystemException {
488    
489                    List<Element> websiteElements =
490                            portletDataContext.getReferenceDataElements(
491                                    organization, Website.class);
492    
493                    List<Website> websites = new ArrayList<Website>(websiteElements.size());
494    
495                    for (Element websiteElement : websiteElements) {
496                            String websitePath = websiteElement.attributeValue("path");
497    
498                            Website website = (Website)portletDataContext.getZipEntryAsObject(
499                                    websitePath);
500    
501                            website.setClassPK(importedOrganization.getOrganizationId());
502    
503                            StagedModelDataHandlerUtil.importReferenceStagedModel(
504                                    portletDataContext, website);
505    
506                            Map<Long, Long> websiteIds =
507                                    (Map<Long, Long>)portletDataContext.getNewPrimaryKeysMap(
508                                            Website.class);
509    
510                            long websiteId = websiteIds.get(website.getPrimaryKey());
511    
512                            website.setWebsiteId(websiteId);
513    
514                            websites.add(website);
515                    }
516    
517                    UsersAdminUtil.updateWebsites(
518                            Organization.class.getName(),
519                            importedOrganization.getOrganizationId(), websites);
520            }
521    
522            @Override
523            protected boolean validateMissingReference(
524                            String uuid, long companyId, long groupId)
525                    throws Exception {
526    
527                    Organization organization =
528                            OrganizationLocalServiceUtil.fetchOrganizationByUuidAndCompanyId(
529                                    uuid, companyId);
530    
531                    if (organization == null) {
532                            return false;
533                    }
534    
535                    return true;
536            }
537    
538    }