提交 6af3451f 编写于 作者: Z zhourui

修复ws调用编码错误

上级 4d2a10cc
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package com.x.base.core.project.webservices;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.util.List;
import org.apache.cxf.Bus;
import org.apache.cxf.BusFactory;
import org.apache.cxf.bus.CXFBusFactory;
import org.apache.cxf.endpoint.EndpointImplFactory;
import org.apache.cxf.endpoint.dynamic.DynamicClientFactory;
import org.apache.cxf.helpers.JavaUtils;
import org.apache.cxf.jaxws.support.JaxWsEndpointImplFactory;
/**
* This class reads a WSDL and creates a dynamic client from it with JAX-WS
* functionality. This provides support for attachments and other useful things
* that come with JAX-WS.
*
* Use {@link #newInstance} to obtain an instance, and then
* {@link #createClient(String)} (or other overloads) to create a client.
*
* This factory uses the JAXB data binding.
**/
public class JaxWsDynamicClientFactory extends DynamicClientFactory {
protected JaxWsDynamicClientFactory(Bus bus) {
super(bus);
}
@Override
protected EndpointImplFactory getEndpointImplFactory() {
return JaxWsEndpointImplFactory.getSingleton();
}
protected boolean allowWrapperOps() {
return true;
}
/**
* Create a new instance using a specific <tt>Bus</tt>.
*
* @param b the <tt>Bus</tt> to use in subsequent operations with the instance
* @return the new instance
*/
public static JaxWsDynamicClientFactory newInstance(Bus b) {
return new JaxWsDynamicClientFactory(b);
}
/**
* Create a new instance using a default <tt>Bus</tt>.
*
* @return the new instance
* @see CXFBusFactory#getDefaultBus()
*/
public static JaxWsDynamicClientFactory newInstance() {
Bus bus = BusFactory.getThreadDefaultBus();
return new JaxWsDynamicClientFactory(bus);
}
protected boolean compileJavaSrc(String classPath, List<File> srcList, String dest) {
org.apache.cxf.common.util.Compiler javaCompiler = new org.apache.cxf.common.util.Compiler();
javaCompiler.setEncoding(StandardCharsets.UTF_8.name());
javaCompiler.setClassPath(classPath);
javaCompiler.setOutputDir(dest);
if (JavaUtils.isJava9Compatible()) {
javaCompiler.setTarget("9");
} else {
javaCompiler.setTarget("1.8");
}
return javaCompiler.compileFiles(srcList);
}
}
\ No newline at end of file
package com.x.base.core.project.webservices;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
public class WebservicesClient {
public Object[] jaxws(String wsdl, String method, Object... objects) {
......
package com.x.meeting.assemble.control;
import com.x.base.core.container.EntityManagerContainer;
public abstract class AbstractFactory {
private Business business;
public AbstractFactory(Business business) throws Exception {
try {
if (null == business) {
throw new Exception("business can not be null.");
}
this.business = business;
} catch (Exception e) {
throw new Exception("can not instantiating factory.");
}
}
public EntityManagerContainer entityManagerContainer() throws Exception {
return this.business.entityManagerContainer();
}
}
\ No newline at end of file
package com.x.meeting.assemble.control;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import com.x.base.core.project.Context;
@WebListener
public class ApplicationServletContextListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
try {
ThisApplication.context = Context.concrete(servletContextEvent);
ThisApplication.init();
ThisApplication.context().regist();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void contextDestroyed(ServletContextEvent servletContextEvent) {
try {
ThisApplication.destroy();
ThisApplication.context.destrory(servletContextEvent);
} catch (Exception e) {
e.printStackTrace();
}
}
}
\ No newline at end of file
package com.x.meeting.assemble.control;
import org.apache.commons.lang3.StringUtils;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.organization.OrganizationDefinition;
import com.x.meeting.assemble.control.factory.AttachmentFactory;
import com.x.meeting.assemble.control.factory.BuildingFactory;
import com.x.meeting.assemble.control.factory.MeetingFactory;
import com.x.meeting.assemble.control.factory.RoomFactory;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
import com.x.organization.core.express.Organization;
public class Business {
private EntityManagerContainer emc;
public Business(EntityManagerContainer emc) throws Exception {
this.emc = emc;
}
public EntityManagerContainer entityManagerContainer() {
return this.emc;
}
private Organization organization;
public Organization organization() throws Exception {
if (null == this.organization) {
this.organization = new Organization(ThisApplication.context());
}
return organization;
}
private MeetingFactory meeting;
public MeetingFactory meeting() throws Exception {
if (null == this.meeting) {
this.meeting = new MeetingFactory(this);
}
return meeting;
}
private BuildingFactory building;
public BuildingFactory building() throws Exception {
if (null == this.building) {
this.building = new BuildingFactory(this);
}
return building;
}
private RoomFactory room;
public RoomFactory room() throws Exception {
if (null == this.room) {
this.room = new RoomFactory(this);
}
return room;
}
private AttachmentFactory attachment;
public AttachmentFactory attachment() throws Exception {
if (null == this.attachment) {
this.attachment = new AttachmentFactory(this);
}
return attachment;
}
public void isManager(EffectivePerson effectivePerson, ExceptionWhen exceptionWhen) throws Exception {
boolean available = this.isManager(effectivePerson);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean isManager(EffectivePerson effectivePerson) throws Exception {
if (effectivePerson.isManager()) {
return true;
}
if (this.organization().person().hasRole(effectivePerson, OrganizationDefinition.MeetingManager)) {
return true;
}
return false;
}
public void buildingEditAvailable(EffectivePerson effectivePerson, ExceptionWhen exceptionWhen) throws Exception {
boolean available = this.buildingEditAvailable(effectivePerson);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean buildingEditAvailable(EffectivePerson effectivePerson) throws Exception {
if (effectivePerson.isManager()) {
return true;
}
if (this.organization().person().hasRole(effectivePerson, OrganizationDefinition.MeetingManager)) {
return true;
}
return false;
}
public void roomEditAvailable(EffectivePerson effectivePerson, Room room, ExceptionWhen exceptionWhen)
throws Exception {
boolean available = this.roomEditAvailable(effectivePerson, room);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean roomEditAvailable(EffectivePerson effectivePerson, Room room) throws Exception {
if (this.buildingEditAvailable(effectivePerson)) {
return true;
}
/* 房间审核员 */
if (StringUtils.equals(effectivePerson.getDistinguishedName(), room.getAuditor())) {
return true;
}
return false;
}
public void meetingAuditAvailable(EffectivePerson effectivePerson, Meeting meeting, ExceptionWhen exceptionWhen)
throws Exception {
boolean available = this.meetingAuditAvailable(effectivePerson, meeting);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean meetingAuditAvailable(EffectivePerson effectivePerson, Meeting meeting) throws Exception {
/* 审核者 */
if (StringUtils.equals(effectivePerson.getDistinguishedName(), meeting.getAuditor())) {
return true;
}
/* 管理员 */
if (this.isManager(effectivePerson)) {
return true;
}
return false;
}
public void meetingEditAvailable(EffectivePerson effectivePerson, Meeting meeting, ExceptionWhen exceptionWhen)
throws Exception {
boolean available = this.meetingEditAvailable(effectivePerson, meeting);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean meetingEditAvailable(EffectivePerson effectivePerson, Meeting meeting) throws Exception {
/* 申请者 */
if (StringUtils.equals(effectivePerson.getDistinguishedName(), meeting.getApplicant())) {
return true;
}
/* 审核者 */
if (this.meetingAuditAvailable(effectivePerson, meeting)) {
return true;
}
return false;
}
public void meetingReadAvailable(EffectivePerson effectivePerson, Meeting meeting, ExceptionWhen exceptionWhen)
throws Exception {
boolean available = this.meetingReadAvailable(effectivePerson, meeting);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean meetingReadAvailable(EffectivePerson effectivePerson, Meeting meeting) throws Exception {
if (this.meetingEditAvailable(effectivePerson, meeting)) {
return true;
}
/* 受邀参加会议 */
if (null != meeting.getInvitePersonList()) {
if (meeting.getInvitePersonList().contains(effectivePerson.getDistinguishedName())) {
return true;
}
}
return false;
}
public void attachmentEditAvailable(EffectivePerson effectivePerson, Meeting meeting, ExceptionWhen exceptionWhen)
throws Exception {
boolean available = this.attachmentEditAvailable(effectivePerson, meeting);
if ((!available) && exceptionWhen.equals(ExceptionWhen.not_allow)) {
throw new Exception(
"person{name:" + effectivePerson.getDistinguishedName() + "} has sufficient permissions");
}
}
public Boolean attachmentEditAvailable(EffectivePerson effectivePerson, Meeting meeting) throws Exception {
if (this.meetingReadAvailable(effectivePerson, meeting)) {
return true;
}
return false;
}
public void estimateConfirmStatus(Meeting meeting) throws Exception {
if (StringUtils.isEmpty(meeting.getAuditor())) {
meeting.setConfirmStatus(ConfirmStatus.allow);
} else if (StringUtils.equals(meeting.getAuditor(), meeting.getApplicant())) {
meeting.setConfirmStatus(ConfirmStatus.allow);
} else {
meeting.setConfirmStatus(ConfirmStatus.wait);
}
}
}
package com.x.meeting.assemble.control;
import com.x.base.core.project.message.MessageConnector;
import com.x.base.core.project.organization.OrganizationDefinition;
import com.x.base.core.project.tools.DateTools;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
public class MessageFactory {
public static void meeting_invite(String person, Meeting meeting, Room room) throws Exception {
String title = "会议邀请:" + meeting.getSubject() + ", 时间:"
+ DateTools.format(meeting.getStartTime(), DateTools.format_yyyyMMddHHmm) + ", 地点:" + room.getName();
MessageConnector.send(MessageConnector.TYPE_MEETING_INVITE, title, person, meeting);
}
public static void meeting_accept(String person, Meeting meeting) throws Exception {
String title = "(" + OrganizationDefinition.name(person) + ")接受了会议:" + meeting.getSubject() + "的邀请.";
MessageConnector.send(MessageConnector.TYPE_MEETING_ACCEPT, title, person, meeting);
}
public static void meeting_reject(String person, Meeting meeting) throws Exception {
String title = "(" + OrganizationDefinition.name(person) + ")拒绝了会议:" + meeting.getSubject() + "的邀请.";
MessageConnector.send(MessageConnector.TYPE_MEETING_REJECT, title, person, meeting);
}
public static void meeting_delete(String person, Meeting meeting) throws Exception {
String title = "会议:" + meeting.getSubject() + "已取消.";
MessageConnector.send(MessageConnector.TYPE_MEETING_DELETE, title, person, meeting);
}
}
package com.x.meeting.assemble.control;
import com.x.base.core.project.Context;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.logger.LoggerFactory;
import com.x.base.core.project.message.MessageConnector;
public class ThisApplication {
protected static Context context;
public static Context context() {
return context;
}
public static void init() {
try {
LoggerFactory.setLevel(Config.logLevel().x_meeting_assemble_control());
MessageConnector.start(context());
} catch (Exception e) {
e.printStackTrace();
}
}
public static void destroy() {
try {
MessageConnector.stop();
} catch (Exception e) {
e.printStackTrace();
}
}
}
package com.x.meeting.assemble.control;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.ListTools;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.wrapout.WrapOutAttachment;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.assemble.control.wrapout.WrapOutRoom;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Building;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
public class WrapTools {
public static WrapCopier<Building, WrapOutBuilding> buildingOutCopier = WrapCopierFactory.wo(Building.class,
WrapOutBuilding.class, null, WrapOutBuilding.Excludes);
public static WrapCopier<Room, WrapOutRoom> roomOutCopier = WrapCopierFactory.wo(Room.class, WrapOutRoom.class,
null, WrapOutRoom.Excludes);
public static WrapCopier<Meeting, WrapOutMeeting> meetingOutCopier = WrapCopierFactory.wo(Meeting.class,
WrapOutMeeting.class, null, WrapOutMeeting.Excludes);
public static WrapCopier<Attachment, WrapOutAttachment> attachmentOutCopier = WrapCopierFactory.wo(Attachment.class,
WrapOutAttachment.class, null, WrapOutAttachment.Excludes);
public static <T extends WrapOutBuilding> void setRoom(Business business, List<T> ts) throws Exception {
for (T t : ts) {
setRoom(business, t);
}
}
public static <T extends WrapOutBuilding> void setRoom(Business business, T t) throws Exception {
List<String> ids = business.room().listWithBuilding(t.getId());
List<WrapOutRoom> list = roomOutCopier.copy(business.entityManagerContainer().list(Room.class, ids));
SortTools.asc(list, false, "floor", "name");
t.setRoomList(list);
}
public static <T extends WrapOutMeeting> void setAttachment(Business business, List<T> ts) throws Exception {
for (T t : ts) {
setAttachment(business, t);
}
}
public static <T extends WrapOutMeeting> void setAttachment(Business business, T t) throws Exception {
List<String> ids = business.attachment().listWithMeeting(t.getId());
List<WrapOutAttachment> list = new ArrayList<>();
list = attachmentOutCopier.copy(business.entityManagerContainer().list(Attachment.class, ids));
SortTools.asc(list, false, "summary", "name");
t.setAttachmentList(list);
}
public static <T extends WrapOutRoom> void setFutureMeeting(Business business, List<T> wraps, boolean allowOnly)
throws Exception {
for (WrapOutRoom wrap : wraps) {
setFutureMeeting(business, wrap, allowOnly);
}
}
public static void setFutureMeeting(Business business, WrapOutRoom wrap, boolean allowOnly) throws Exception {
List<String> ids = new ArrayList<>();
ids = business.meeting().listFutureWithRoom(wrap.getId(), allowOnly);
List<WrapOutMeeting> list = meetingOutCopier.copy(business.entityManagerContainer().list(Meeting.class, ids));
SortTools.asc(list, false, "startTime");
wrap.setMeetingList(list);
}
public static <T extends WrapOutMeeting> void decorate(Business business, List<T> list,
EffectivePerson effectivePerson) throws Exception {
for (T o : list) {
decorate(business, o, effectivePerson);
}
}
public static <T extends WrapOutMeeting> void decorate(Business business, T t, EffectivePerson effectivePerson)
throws Exception {
Date now = new Date();
if (now.before(t.getStartTime())) {
t.setStatus("wait");
} else if (now.after(t.getCompletedTime())) {
t.setStatus("completed");
} else {
t.setStatus("processing");
}
t.setMyApply(false);
t.setMyWaitConfirm(false);
t.setMyWaitAccept(false);
t.setMyAccept(false);
t.setMyReject(false);
if (StringUtils.equalsIgnoreCase(effectivePerson.getDistinguishedName(), t.getApplicant())) {
t.setMyApply(true);
}
if (StringUtils.equalsIgnoreCase(effectivePerson.getDistinguishedName(), t.getAuditor())
&& ConfirmStatus.wait.equals(t.getConfirmStatus())) {
t.setMyWaitConfirm(true);
}
if (ConfirmStatus.allow.equals(t.getConfirmStatus()) && (StringUtils.equals(t.getStatus(), "wait"))
&& (t.getManualCompleted() == false)) {
if (ListTools.contains(t.getInvitePersonList(), effectivePerson.getDistinguishedName())) {
if ((!ListTools.contains(t.getAcceptPersonList(), effectivePerson.getDistinguishedName()))
&& (!ListTools.contains(t.getRejectPersonList(), effectivePerson.getDistinguishedName()))) {
t.setMyWaitAccept(true);
}
if (ListTools.contains(t.getAcceptPersonList(), effectivePerson.getDistinguishedName())) {
t.setMyAccept(true);
}
if (ListTools.contains(t.getRejectPersonList(), effectivePerson.getDistinguishedName())) {
t.setMyReject(true);
}
}
}
Room room = business.entityManagerContainer().find(t.getRoom(), Room.class);
if (null != room) {
t.setWoRoom(WrapTools.roomOutCopier.copy(room));
}
}
public static void checkRoomIdle(Business business, WrapOutRoom wrap, Date start, Date completed) throws Exception {
wrap.setIdle(business.room().checkIdle(wrap.getId(), start, completed, ""));
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.factory;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import com.x.meeting.assemble.control.AbstractFactory;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Attachment_;
public class AttachmentFactory extends AbstractFactory {
public AttachmentFactory(Business business) throws Exception {
super(business);
}
public List<String> listWithMeeting(String meetingId) throws Exception {
EntityManager em = this.entityManagerContainer().get(Attachment.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Attachment> root = cq.from(Attachment.class);
Predicate p = cb.equal(root.get(Attachment_.meeting), meetingId);
cq.select(root.get(Attachment_.id)).where(p);
return em.createQuery(cq).getResultList();
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.factory;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import com.x.meeting.assemble.control.AbstractFactory;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Building;
import com.x.meeting.core.entity.Building_;
public class BuildingFactory extends AbstractFactory {
public BuildingFactory(Business business) throws Exception {
super(business);
}
public List<String> list() throws Exception {
EntityManager em = this.entityManagerContainer().get(Building.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Building> root = cq.from(Building.class);
cq.select(root.get(Building_.id));
return em.createQuery(cq).getResultList();
}
//@MethodDescribe("列示所有首字母开始的Building.")
public List<String> listPinyinInitial(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Building.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Building> root = cq.from(Building.class);
Predicate p = cb.like(root.get(Building_.pinyinInitial), str + "%", '\\');
cq.select(root.get(Building_.id)).where(p);
return em.createQuery(cq).getResultList();
}
//@MethodDescribe("进行模糊查询.")
public List<String> listLike(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Building.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Building> root = cq.from(Building.class);
Predicate p = cb.like(root.get(Building_.name), "%" + str + "%", '\\');
p = cb.or(p, cb.like(root.get(Building_.pinyin), str + "%", '\\'));
p = cb.or(p, cb.like(root.get(Building_.pinyinInitial), str + "%", '\\'));
cq.select(root.get(Building_.id)).where(p);
return em.createQuery(cq).setMaxResults(200).getResultList();
}
//@MethodDescribe("根据拼音进行模糊查询.")
public List<String> listLikePinyin(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Building.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Building> root = cq.from(Building.class);
Predicate p = cb.like(root.get(Building_.pinyin), str + "%");
p = cb.or(p, cb.like(root.get(Building_.pinyinInitial), str + "%"));
cq.select(root.get(Building_.id)).where(p);
return em.createQuery(cq).setMaxResults(200).getResultList();
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.factory;
import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import com.x.meeting.assemble.control.AbstractFactory;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Meeting_;
public class MeetingFactory extends AbstractFactory {
public MeetingFactory(Business business) throws Exception {
super(business);
}
public List<String> listWithRoom(String roomId) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.equal(root.get(Meeting_.room), roomId);
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithAppliedWait(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.equal(root.get(Meeting_.applicant), person);
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
p = cb.and(p, cb.greaterThan(root.get(Meeting_.startTime), new Date()));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithAppliedProcessing(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Date date = new Date();
Predicate p = cb.equal(root.get(Meeting_.applicant), person);
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.startTime), date));
p = cb.and(p, cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), date));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithAppliedCompleted(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.equal(root.get(Meeting_.applicant), person);
p = cb.and(p, cb.or(cb.lessThan(root.get(Meeting_.completedTime), new Date()),
cb.equal(root.get(Meeting_.manualCompleted), true)));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithInvitedWait(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.isMember(person, root.get(Meeting_.invitePersonList));
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
p = cb.and(p, cb.greaterThan(root.get(Meeting_.startTime), new Date()));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithInvitedProcessing(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Date date = new Date();
Predicate p = cb.isMember(person, root.get(Meeting_.invitePersonList));
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.startTime), date));
p = cb.and(p, cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), date));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithInvitedCompleted(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.isMember(person, root.get(Meeting_.invitePersonList));
p = cb.and(p, cb.or(cb.lessThan(root.get(Meeting_.completedTime), new Date()),
cb.equal(root.get(Meeting_.manualCompleted), true)));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithInvitedRejected(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.isMember(person, root.get(Meeting_.invitePersonList));
p = cb.and(p, cb.isMember(person, root.get(Meeting_.rejectPersonList)));
p = cb.and(p, cb.lessThan(root.get(Meeting_.completedTime), new Date()));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithPersonWaitAccept(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), new Date());
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
p = cb.and(p, cb.isMember(person, root.get(Meeting_.invitePersonList)));
p = cb.and(p, cb.isNotMember(person, root.get(Meeting_.acceptPersonList)));
p = cb.and(p, cb.isNotMember(person, root.get(Meeting_.rejectPersonList)));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWaitConfirm() throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), new Date());
p = cb.and(p, cb.equal(root.get(Meeting_.confirmStatus), ConfirmStatus.wait));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithPersonWaitConfirm(String person) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), new Date());
p = cb.and(p, cb.equal(root.get(Meeting_.confirmStatus), ConfirmStatus.wait));
p = cb.and(p,
cb.or(cb.equal(root.get(Meeting_.applicant), person), cb.equal(root.get(Meeting_.auditor), person),
cb.isMember(person, root.get(Meeting_.invitePersonList))));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithDate(Date start, Date end) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
//Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.startTime), start);
//p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.startTime), end));
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), start);
p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.completedTime), end));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listWithPersonWithDate(String person, Date start, Date end) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
//Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.startTime), start);
//p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.startTime), end));
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), start);
p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.completedTime), end));
p = cb.and(p,
cb.or(cb.equal(root.get(Meeting_.applicant), person), cb.equal(root.get(Meeting_.auditor), person),
cb.isMember(person, root.get(Meeting_.invitePersonList))));
p = cb.and(p, cb.equal(root.get(Meeting_.manualCompleted), false));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public List<String> listFutureWithRoom(String roomId, boolean allowOnly) throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
//Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.startTime), new Date());
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), new Date());
p = cb.and(p, cb.equal(root.get(Meeting_.room), roomId));
p = cb.and(p, cb.equal(root.get(Meeting_.manualCompleted), false));
if (allowOnly) {
p = cb.and(p, cb.equal(root.get(Meeting_.confirmStatus), ConfirmStatus.allow));
}
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
// @MethodDescribe("列示所有首字母开始的Building.")
public List<String> listPinyinInitial(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.like(root.get(Meeting_.pinyinInitial), str + "%", '\\');
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).getResultList();
}
//@MethodDescribe("进行模糊查询.")
public List<String> listLike(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.like(root.get(Meeting_.subject), "%" + str + "%", '\\');
p = cb.or(p, cb.like(root.get(Meeting_.pinyin), str + "%", '\\'));
p = cb.or(p, cb.like(root.get(Meeting_.pinyinInitial), str + "%", '\\'));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).setMaxResults(200).getResultList();
}
//@MethodDescribe("根据拼音进行模糊查询.")
public List<String> listLikePinyin(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.like(root.get(Meeting_.pinyin), str + "%");
p = cb.or(p, cb.like(root.get(Meeting_.pinyinInitial), str + "%"));
cq.select(root.get(Meeting_.id)).where(p);
return em.createQuery(cq).setMaxResults(200).getResultList();
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.factory;
import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.apache.commons.lang3.StringUtils;
import com.x.meeting.assemble.control.AbstractFactory;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Meeting_;
import com.x.meeting.core.entity.Room;
import com.x.meeting.core.entity.Room_;
public class RoomFactory extends AbstractFactory {
public RoomFactory(Business business) throws Exception {
super(business);
}
/* 列示所有的Room */
public List<String> list() throws Exception {
EntityManager em = this.entityManagerContainer().get(Room.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Room> root = cq.from(Room.class);
cq.select(root.get(Room_.id));
return em.createQuery(cq).getResultList();
}
public List<String> listWithBuilding(String floorId) throws Exception {
EntityManager em = this.entityManagerContainer().get(Room.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Room> root = cq.from(Room.class);
Predicate p = cb.equal(root.get(Room_.building), floorId);
cq.select(root.get(Room_.id)).where(p);
return em.createQuery(cq).getResultList();
}
public boolean checkIdle(String roomId, Date startTime, Date completedTime, String excludeMeetingId)
throws Exception {
EntityManager em = this.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Long> cq = cb.createQuery(Long.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.equal(root.get(Meeting_.room), roomId);
p = cb.and(p, cb.equal(root.get(Meeting_.manualCompleted), false));
p = cb.and(p, cb.equal(root.get(Meeting_.confirmStatus), ConfirmStatus.allow));
if (StringUtils.isNotEmpty(excludeMeetingId)) {
p = cb.and(p, cb.notEqual(root.get(Meeting_.id), excludeMeetingId));
}
p = cb.and(p,
cb.or(cb.between(root.get(Meeting_.startTime), startTime, completedTime),
cb.between(root.get(Meeting_.completedTime), startTime, completedTime),
cb.and(cb.lessThanOrEqualTo(root.get(Meeting_.startTime), startTime),
cb.greaterThanOrEqualTo(root.get(Meeting_.completedTime), completedTime))));
cq.select(cb.count(root)).where(p);
return em.createQuery(cq).getSingleResult() == 0L;
}
//@MethodDescribe("列示所有首字母开始的Room.")
public List<String> listPinyinInitial(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Room.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Room> root = cq.from(Room.class);
Predicate p = cb.like(root.get(Room_.pinyinInitial), str + "%", '\\');
cq.select(root.get(Room_.id)).where(p);
return em.createQuery(cq).getResultList();
}
//@MethodDescribe("进行模糊查询.")
public List<String> listLike(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Room.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Room> root = cq.from(Room.class);
Predicate p = cb.like(root.get(Room_.name), "%" + str + "%", '\\');
p = cb.or(p, cb.like(root.get(Room_.pinyin), str + "%", '\\'));
p = cb.or(p, cb.like(root.get(Room_.pinyinInitial), str + "%", '\\'));
cq.select(root.get(Room_.id)).where(p);
return em.createQuery(cq).setMaxResults(200).getResultList();
}
//@MethodDescribe("根据拼音进行模糊查询.")
public List<String> listLikePinyin(String key) throws Exception {
String str = key.replaceAll("_", "\\\\_");
str = str.replaceAll("%", "\\\\%");
str = str.toLowerCase();
EntityManager em = this.entityManagerContainer().get(Room.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<String> cq = cb.createQuery(String.class);
Root<Room> root = cq.from(Room.class);
Predicate p = cb.like(root.get(Room_.pinyin), str + "%");
p = cb.or(p, cb.like(root.get(Room_.pinyinInitial), str + "%"));
cq.select(root.get(Room_.id)).where(p);
return em.createQuery(cq).setMaxResults(200).getResultList();
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs;
import java.util.Set;
import javax.ws.rs.ApplicationPath;
import com.x.base.core.project.jaxrs.AbstractActionApplication;
import com.x.meeting.assemble.control.jaxrs.attachment.AttachmentAction;
import com.x.meeting.assemble.control.jaxrs.building.BuildingAction;
import com.x.meeting.assemble.control.jaxrs.meeting.MeetingAction;
import com.x.meeting.assemble.control.jaxrs.openmeeting.OpenMeetingAction;
import com.x.meeting.assemble.control.jaxrs.room.RoomAction;
@ApplicationPath("jaxrs")
public class ActionApplication extends AbstractActionApplication {
public Set<Class<?>> getClasses() {
classes.add(BuildingAction.class);
classes.add(RoomAction.class);
classes.add(MeetingAction.class);
classes.add(AttachmentAction.class);
classes.add(OpenMeetingAction.class);
return classes;
}
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/jaxrs/attachment/*", asyncSupported = true)
public class AttachmentJaxrsFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/servlet/attachment/*", asyncSupported = true)
public class AttachmentServletFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/jaxrs/building/*", asyncSupported = true)
public class BuildingJaxrsFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/jaxrs/floor/*", asyncSupported = true)
public class FloorJaxrsFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/jaxrs/meeting/*", asyncSupported = true)
public class MeetingJaxrsFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.CipherManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/jaxrs/openmeeting/*", asyncSupported = true)
public class OpenMeetingJaxrsFilter extends CipherManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/jaxrs/room/*", asyncSupported = true)
public class RoomJaxrsFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs;
import javax.servlet.annotation.WebFilter;
import com.x.base.core.project.jaxrs.ManagerUserJaxrsFilter;
@WebFilter(urlPatterns = "/servlet/room/*", asyncSupported = true)
public class RoomServletFilter extends ManagerUserJaxrsFilter {
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.util.Date;
import java.util.List;
import org.apache.commons.io.IOUtils;
import com.google.gson.JsonElement;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.Application;
import com.x.base.core.project.Applications;
import com.x.base.core.project.x_processplatform_assemble_surface;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.connection.CipherConnectionAction;
import com.x.base.core.project.connection.HttpConnection;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.gson.GsonPropertyObject;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WrapBoolean;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionCreateFormProcessPlatform extends BaseAction {
public ActionResult<Wo> execute(EffectivePerson effectivePerson, JsonElement jsonElement) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Wi wi = this.convertToWrapIn(jsonElement, Wi.class);
Business business = new Business(emc);
Meeting meeting = emc.find(wi.getMeeting(), Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExist(wi.getMeeting());
}
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
StorageMapping mapping = ThisApplication.context().storageMappings().random(Attachment.class);
for (String workAttachment : wi.getAttachmentList()) {
String fileName = readAttachmentName(wi.getWork(), workAttachment);
emc.beginTransaction(Attachment.class);
byte[] bytes = readAttachmentContent(wi.getWork(), workAttachment);
Attachment attachment = this.concreteAttachment(meeting, false);
attachment.saveContent(mapping, bytes, fileName);
attachment.setLastUpdatePerson(effectivePerson.getDistinguishedName());
attachment.setLastUpdateTime(new Date());
emc.persist(attachment, CheckPersistType.all);
emc.commit();
}
Wo wo = new Wo();
wo.setValue(true);
result.setData(wo);
return result;
}
}
private String readAttachmentName(String workId, String workAttachmentId) throws Exception {
RespAttachmentName resp = ThisApplication.context().applications()
.getQuery(x_processplatform_assemble_surface.class,
Applications.joinQueryUri("attachment", workAttachmentId, "work", workId))
.getData(RespAttachmentName.class);
return resp.getName();
}
public static class RespAttachmentName {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
private byte[] readAttachmentContent(String workId, String workAttachmentId) throws Exception {
Application app = ThisApplication.context().applications()
.randomWithWeight(x_processplatform_assemble_surface.class.getName());
String address = app.getUrlJaxrsRoot() + "attachment/download/" + workAttachmentId + "/work/" + workId;
HttpURLConnection connection = HttpConnection.prepare(address, CipherConnectionAction.cipher());
connection.setRequestMethod("GET");
connection.setDoOutput(false);
connection.setDoInput(true);
byte[] bytes = null;
connection.connect();
try (InputStream input = connection.getInputStream()) {
bytes = IOUtils.toByteArray(input);
}
connection.disconnect();
return bytes;
}
public static class Wi extends GsonPropertyObject {
@FieldDescribe("会议标识")
private String meeting;
@FieldDescribe("工作标识")
private String work;
@FieldDescribe("附件标识")
private List<String> attachmentList;
public String getMeeting() {
return meeting;
}
public void setMeeting(String meeting) {
this.meeting = meeting;
}
public String getWork() {
return work;
}
public void setWork(String work) {
this.work = work;
}
public List<String> getAttachmentList() {
return attachmentList;
}
public void setAttachmentList(List<String> attachmentList) {
this.attachmentList = attachmentList;
}
}
public static class Wo extends WrapBoolean {
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.http.WrapOutId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
class ActionDelete extends BaseAction {
ActionResult<WrapOutId> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<WrapOutId> result = new ActionResult<>();
Business business = new Business(emc);
Attachment attachment = emc.find(id, Attachment.class, ExceptionWhen.not_found);
Meeting meeting = emc.find(attachment.getMeeting(), Meeting.class, ExceptionWhen.not_found);
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
emc.beginTransaction(Attachment.class);
StorageMapping mapping = ThisApplication.context().storageMappings().get(Attachment.class,
attachment.getStorage());
attachment.deleteContent(mapping);
emc.remove(attachment);
emc.commit();
WrapOutId wrap = new WrapOutId(meeting.getId());
result.setData(wrap);
return result;
}
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import org.apache.commons.lang3.BooleanUtils;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoFile;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionDownload extends BaseAction {
public ActionResult<Wo> execute(EffectivePerson effectivePerson, String id, Boolean stream) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Attachment attachment = emc.find(id, Attachment.class);
if (null == attachment) {
throw new ExceptionAttachmentNotExist(id);
}
Meeting meeting = emc.find(attachment.getMeeting(), Meeting.class, ExceptionWhen.not_found);
if (null == meeting) {
throw new ExceptionMeetingNotExist(attachment.getMeeting());
}
if (BooleanUtils.isNotTrue(Config.meeting().getAnonymousAccessAttachment())) {
if (!business.meetingReadAvailable(effectivePerson, meeting)) {
throw new ExceptionMeetingAccessDenied(effectivePerson, meeting.getSubject());
}
}
StorageMapping mapping = ThisApplication.context().storageMappings().get(Attachment.class,
attachment.getStorage());
Wo wo = new Wo(attachment.readContent(mapping), this.contentType(stream, attachment.getName()),
this.contentDisposition(stream, attachment.getName()));
result.setData(wo);
return result;
}
}
public static class Wo extends WoFile {
public Wo(byte[] bytes, String contentType, String contentDisposition) {
super(bytes, contentType, contentDisposition);
}
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.wrapout.WrapOutAttachment;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionGet extends BaseAction {
public ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
Business business = new Business(emc);
ActionResult<Wo> result = new ActionResult<>();
Attachment attachment = emc.find(id, Attachment.class);
if (null == attachment) {
throw new ExceptionEntityNotExist(id, Attachment.class);
}
Meeting meeting = emc.find(attachment.getMeeting(), Meeting.class);
if (null == meeting) {
throw new ExceptionEntityNotExist(attachment.getMeeting(), Meeting.class);
}
if (!business.meetingReadAvailable(effectivePerson, meeting)) {
throw new ExceptionAccessDenied(effectivePerson);
}
Wo wo = Wo.copier.copy(attachment);
result.setData(wo);
return result;
}
}
public static class Wo extends WrapOutAttachment {
private static final long serialVersionUID = 5214287925527371610L;
public static WrapCopier<Attachment, Wo> copier = WrapCopierFactory.wo(Attachment.class, Wo.class, null,
Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.organization.OrganizationDefinition;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Attachment;
class ActionListNext extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String id, Integer count) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
if (effectivePerson.isNotManager() && (!business.organization().person().hasRole(effectivePerson,
OrganizationDefinition.Manager, OrganizationDefinition.MeetingManager))) {
throw new ExceptionAccessDenied(effectivePerson);
}
result = this.standardListNext(Wo.copier, id, count, JpaObject.sequence_FIELDNAME, null, null, null, null, null, null, null,
null, true, DESC);
return result;
}
}
public static class Wo extends Attachment {
private static final long serialVersionUID = 5214287925527371610L;
public static WrapCopier<Attachment, Wo> copier = WrapCopierFactory.wo(Attachment.class, Wo.class, null,
JpaObject.FieldsInvisible);
@FieldDescribe("排序号")
private Long rank;
public Long getRank() {
return rank;
}
public void setRank(Long rank) {
this.rank = rank;
}
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.organization.OrganizationDefinition;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Attachment;
class ActionListPrev extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String id, Integer count) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
if (effectivePerson.isNotManager() && (!business.organization().person().hasRole(effectivePerson,
OrganizationDefinition.Manager, OrganizationDefinition.MeetingManager))) {
throw new ExceptionAccessDenied(effectivePerson);
}
result = this.standardListPrev(Wo.copier, id, count, JpaObject.sequence_FIELDNAME, null, null, null, null, null, null, null,
null, true, DESC);
return result;
}
}
public static class Wo extends Attachment {
private static final long serialVersionUID = 5214287925527371610L;
public static WrapCopier<Attachment, Wo> copier = WrapCopierFactory.wo(Attachment.class, Wo.class, null,
JpaObject.FieldsInvisible);
@FieldDescribe("排序号")
private Long rank;
public Long getRank() {
return rank;
}
public void setRank(Long rank) {
this.rank = rank;
}
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionListWithMeeting extends BaseAction {
public ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String meetingId) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(meetingId, Meeting.class, ExceptionWhen.not_found);
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
List<String> ids = business.attachment().listWithMeeting(meeting.getId());
List<Wo> wos = Wo.copier.copy(emc.list(Attachment.class, ids));
SortTools.asc(wos, false, Attachment.summary_FIELDNAME, Attachment.name_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends Attachment {
private static final long serialVersionUID = 5214287925527371610L;
public static WrapCopier<Attachment, Wo> copier = WrapCopierFactory.wo(Attachment.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Date;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionUpdate extends BaseAction {
public ActionResult<Wo> execute(EffectivePerson effectivePerson, String id, byte[] bytes,
FormDataContentDisposition disposition) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Attachment attachment = emc.find(id, Attachment.class, ExceptionWhen.not_found);
if (null == attachment) {
throw new ExceptionAttachmentNotExist(id);
}
Meeting meeting = emc.find(attachment.getMeeting(), Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExist(attachment.getMeeting());
}
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
try (InputStream input = new ByteArrayInputStream(bytes)) {
StorageMapping mapping = ThisApplication.context().storageMappings().get(Attachment.class,
attachment.getStorage());
attachment.updateContent(mapping, input);
attachment.setLastUpdatePerson(effectivePerson.getDistinguishedName());
attachment.setLastUpdateTime(new Date());
emc.beginTransaction(Attachment.class);
emc.persist(attachment);
emc.commit();
}
Wo wo = new Wo();
wo.setId(id);
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Date;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoCallback;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionUpdateCallback extends BaseAction {
public ActionResult<Wo<WoObject>> execute(EffectivePerson effectivePerson, String id, String callback, byte[] bytes,
FormDataContentDisposition disposition) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo<WoObject>> result = new ActionResult<>();
Business business = new Business(emc);
Attachment attachment = emc.find(id, Attachment.class, ExceptionWhen.not_found);
if (null == attachment) {
throw new ExceptionAttachmentNotExistCallback(callback, id);
}
Meeting meeting = emc.find(attachment.getMeeting(), Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExistCallback(callback, attachment.getMeeting());
}
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
try (InputStream input = new ByteArrayInputStream(bytes)) {
StorageMapping mapping = ThisApplication.context().storageMappings().get(Attachment.class,
attachment.getStorage());
attachment.updateContent(mapping, input);
attachment.setLastUpdatePerson(effectivePerson.getDistinguishedName());
attachment.setLastUpdateTime(new Date());
emc.beginTransaction(Attachment.class);
emc.persist(attachment);
emc.commit();
}
WoObject woObject = new WoObject();
woObject.setId(attachment.getId());
Wo<WoObject> wo = new Wo<>(callback, woObject);
result.setData(wo);
return result;
}
}
public static class Wo<T> extends WoCallback<T> {
public Wo(String callbackName, T t) {
super(callbackName, t);
}
}
public static class WoObject extends WoId {
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Date;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionUpload extends BaseAction {
public ActionResult<Wo> execute(EffectivePerson effectivePerson, String meetingId, Boolean summary, String fileName,
byte[] bytes, FormDataContentDisposition disposition) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(meetingId, Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExist(meetingId);
}
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
try (InputStream input = new ByteArrayInputStream(bytes)) {
StorageMapping mapping = ThisApplication.context().storageMappings().random(Attachment.class);
emc.beginTransaction(Attachment.class);
fileName = StringUtils.isEmpty(fileName) ? disposition.getFileName() : fileName;
fileName = FilenameUtils.getName(fileName);
Attachment attachment = this.concreteAttachment(meeting, summary);
attachment.saveContent(mapping, input, fileName);
attachment.setLastUpdatePerson(effectivePerson.getDistinguishedName());
attachment.setLastUpdateTime(new Date());
emc.persist(attachment, CheckPersistType.all);
emc.commit();
Wo wo = new Wo();
wo.setId(attachment.getId());
result.setData(wo);
}
return result;
}
}
public static class Wo extends WoId {
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Date;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoCallback;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
public class ActionUploadCallback extends BaseAction {
public ActionResult<Wo<WoObject>> execute(EffectivePerson effectivePerson, String meetingId, Boolean summary,
String callback, String fileName, byte[] bytes, FormDataContentDisposition disposition) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo<WoObject>> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(meetingId, Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExistCallback(callback, meetingId);
}
business.meetingReadAvailable(effectivePerson, meeting, ExceptionWhen.not_allow);
try (InputStream input = new ByteArrayInputStream(bytes)) {
StorageMapping mapping = ThisApplication.context().storageMappings().random(Attachment.class);
emc.beginTransaction(Attachment.class);
fileName = StringUtils.isEmpty(fileName) ? disposition.getFileName() : fileName;
fileName = FilenameUtils.getName(fileName);
Attachment attachment = this.concreteAttachment(meeting, summary);
attachment.saveContent(mapping, input, fileName);
attachment.setLastUpdatePerson(effectivePerson.getDistinguishedName());
attachment.setLastUpdateTime(new Date());
emc.persist(attachment, CheckPersistType.all);
emc.commit();
WoObject woObject = new WoObject();
woObject.setId(attachment.getId());
Wo<WoObject> wo = new Wo<>(callback, woObject);
result.setData(wo);
}
return result;
}
}
public static class Wo<T> extends WoCallback<T> {
public Wo(String callbackName, T t) {
super(callbackName, t);
}
}
public static class WoObject extends WoId {
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.attachment;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import org.glassfish.jersey.media.multipart.FormDataContentDisposition;
import org.glassfish.jersey.media.multipart.FormDataParam;
import com.google.gson.JsonElement;
import com.x.base.core.project.annotation.JaxrsDescribe;
import com.x.base.core.project.annotation.JaxrsMethodDescribe;
import com.x.base.core.project.annotation.JaxrsParameterDescribe;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.http.HttpMediaType;
import com.x.base.core.project.http.WrapOutId;
import com.x.base.core.project.jaxrs.ResponseFactory;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
import com.x.base.core.project.logger.Logger;
import com.x.base.core.project.logger.LoggerFactory;
@Path("attachment")
@JaxrsDescribe("附件")
public class AttachmentAction extends StandardJaxrsAction {
private static Logger logger = LoggerFactory.getLogger(AttachmentAction.class);
@JaxrsMethodDescribe(value = "获取指定的Attachment信息.", action = ActionGet.class)
@GET
@Path("{id}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void get(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("id") String id) {
ActionResult<ActionGet.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionGet().execute(effectivePerson, id);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "将流程平台中的work附带的附件作为会议的附件.", action = ActionCreateFormProcessPlatform.class)
@POST
@Path("create/from/processplatform")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void createFormProcessPlatform(@Suspended final AsyncResponse asyncResponse,
@Context HttpServletRequest request, JsonElement jsonElement) {
ActionResult<ActionCreateFormProcessPlatform.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionCreateFormProcessPlatform().execute(effectivePerson, jsonElement);
} catch (Exception e) {
logger.error(e, effectivePerson, request, jsonElement);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "列示Attachment对象,下一页.仅管理员可用", action = ActionListNext.class)
@GET
@Path("list/{id}/next/{count}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listNext(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("标识") @PathParam("id") String id,
@JaxrsParameterDescribe("数量") @PathParam("count") Integer count) {
ActionResult<List<ActionListNext.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListNext().execute(effectivePerson, id, count);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "列示Attachment对象,上一页.仅管理员可用", action = ActionListPrev.class)
@GET
@Path("list/{id}/prev/{count}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listPrev(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("标识") @PathParam("id") String id,
@JaxrsParameterDescribe("数量") @PathParam("count") Integer count) {
ActionResult<List<ActionListPrev.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListPrev().execute(effectivePerson, id, count);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "列示指定会议的附件.", action = ActionListWithMeeting.class)
@GET
@Path("list/meeting/{meetingId}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listWithMeeting(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("会议标识") @PathParam("meetingId") String meetingId) {
ActionResult<List<ActionListWithMeeting.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListWithMeeting().execute(effectivePerson, meetingId);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "删除Attachment.", action = ActionDelete.class)
@DELETE
@Path("{id}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void delete(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("标识") @PathParam("id") String id) {
ActionResult<WrapOutId> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionDelete().execute(effectivePerson, id);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "下载附件内容.", action = ActionDownload.class)
@GET
@Path("{id}/download/{stream}")
@Consumes(MediaType.APPLICATION_JSON)
public void download(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("附件标识") @PathParam("id") String id,
@JaxrsParameterDescribe("是否直接下载附件,不使用浏览器打开") @PathParam("stream") boolean stream) {
ActionResult<ActionDownload.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionDownload().execute(effectivePerson, id, stream);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "创建会议附件.", action = ActionUpload.class)
@POST
@Path("meeting/{meetingId}/upload/{summary}")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
public void upload(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("会议标识") @PathParam("meetingId") String meetingId,
@JaxrsParameterDescribe("是否是会议纪要") @PathParam("summary") boolean summary,
@FormDataParam(FILENAME_FIELD) String fileName, @FormDataParam(FILE_FIELD) final byte[] bytes,
@JaxrsParameterDescribe("文件") @FormDataParam(FILE_FIELD) final FormDataContentDisposition disposition) {
ActionResult<ActionUpload.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionUpload().execute(effectivePerson, meetingId, summary, fileName, bytes, disposition);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
/** callback方法与前台ie低版本兼容使用post方法 */
@JaxrsMethodDescribe(value = "创建会议附件.", action = ActionUploadCallback.class)
@POST
@Path("meeting/{meetingId}/upload/{summary}/callback/{callback}")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@Produces(HttpMediaType.TEXT_HTML_UTF_8)
public void uploadCallback(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("会议标识") @PathParam("meetingId") String meetingId,
@JaxrsParameterDescribe("是否是会议纪要") @PathParam("summary") boolean summary,
@JaxrsParameterDescribe("回调函数名") @PathParam("callback") String callback,
@FormDataParam(FILENAME_FIELD) String fileName, @FormDataParam(FILE_FIELD) final byte[] bytes,
@JaxrsParameterDescribe("文件") @FormDataParam(FILE_FIELD) final FormDataContentDisposition disposition) {
ActionResult<ActionUploadCallback.Wo<ActionUploadCallback.WoObject>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionUploadCallback().execute(effectivePerson, meetingId, summary, callback, fileName, bytes,
disposition);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "更新会议附件内容", action = ActionUpdate.class)
@PUT
@Path("{id}/update")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
public void update(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("会议标识") @PathParam("id") String id, @FormDataParam(FILE_FIELD) final byte[] bytes,
@JaxrsParameterDescribe("文件") @FormDataParam(FILE_FIELD) final FormDataContentDisposition disposition) {
ActionResult<ActionUpdate.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionUpdate().execute(effectivePerson, id, bytes, disposition);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
/** callback方法与前台ie低版本兼容使用post方法 */
@JaxrsMethodDescribe(value = "更新会议附件内容", action = ActionUpdateCallback.class)
@POST
@Path("{id}/update/callback/{ballback}")
@Consumes(MediaType.MULTIPART_FORM_DATA)
@Produces(HttpMediaType.TEXT_HTML_UTF_8)
public void updateCallback(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@JaxrsParameterDescribe("会议标识") @PathParam("id") String id,
@JaxrsParameterDescribe("回调函数名") @PathParam("callback") String callback,
@FormDataParam(FILE_FIELD) final byte[] bytes,
@JaxrsParameterDescribe("文件") @FormDataParam(FILE_FIELD) final FormDataContentDisposition disposition) {
ActionResult<ActionUpdateCallback.Wo<ActionUpdateCallback.WoObject>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionUpdateCallback().execute(effectivePerson, id, callback, bytes, disposition);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.Meeting;
abstract class BaseAction extends StandardJaxrsAction {
protected Attachment concreteAttachment(Meeting meeting, Boolean summary) throws Exception {
Attachment attachment = new Attachment();
attachment.setMeeting(meeting.getId());
attachment.setSummary(summary);
return attachment;
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.project.exception.PromptException;
class ExceptionAttachmentNotExist extends PromptException {
private static final long serialVersionUID = 7237855733312562652L;
ExceptionAttachmentNotExist(String id) {
super("附件: {} 不存在.", id);
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.project.exception.CallbackPromptException;
class ExceptionAttachmentNotExistCallback extends CallbackPromptException {
private static final long serialVersionUID = 7237855733312562652L;
ExceptionAttachmentNotExistCallback(String callbackName, String id) {
super(callbackName, "附件: {} 不存在.", id);
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.project.exception.PromptException;
import com.x.base.core.project.http.EffectivePerson;
class ExceptionMeetingAccessDenied extends PromptException {
private static final long serialVersionUID = 7237855733312562652L;
ExceptionMeetingAccessDenied(EffectivePerson effectivePerson, String name) {
super("用户: {} 访问会议:{} 权限不足..", effectivePerson.getName(), name);
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.project.exception.PromptException;
class ExceptionMeetingNotExist extends PromptException {
private static final long serialVersionUID = 7237855733312562652L;
ExceptionMeetingNotExist(String id) {
super("会议: {} 不存在.", id);
}
}
package com.x.meeting.assemble.control.jaxrs.attachment;
import com.x.base.core.project.exception.CallbackPromptException;
class ExceptionMeetingNotExistCallback extends CallbackPromptException {
private static final long serialVersionUID = 7237855733312562652L;
ExceptionMeetingNotExistCallback(String callbackName, String id) {
super(callbackName, "会议: {} 不存在.", id);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import com.google.gson.JsonElement;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionCreate extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, JsonElement jsonElement) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Wi wi = this.convertToWrapIn(jsonElement, Wi.class);
Business business = new Business(emc);
if (!business.buildingEditAvailable(effectivePerson)) {
throw new ExceptionAccessDenied(effectivePerson);
}
Building o = Wi.copier.copy(wi);
emc.beginTransaction(Building.class);
emc.persist(o, CheckPersistType.all);
emc.commit();
Wo wo = new Wo();
wo.setId(o.getId());
result.setData(wo);
return result;
}
}
public static class Wi extends Building {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Wi, Building> copier = WrapCopierFactory.wi(Wi.class, Building.class, null,
JpaObject.FieldsInvisible);
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.entity.annotation.CheckRemoveType;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionDelete extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
if (!business.buildingEditAvailable(effectivePerson)) {
throw new ExceptionAccessDenied(effectivePerson);
}
Building o = emc.find(id, Building.class);
if (null == o) {
throw new ExceptionEntityNotExist(id, Building.class);
}
emc.beginTransaction(Building.class);
emc.remove(o, CheckRemoveType.all);
emc.commit();
Wo wo = new Wo();
wo.setId(o.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import com.google.gson.JsonElement;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionEdit extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id, JsonElement jsonElement) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Wi wi = this.convertToWrapIn(jsonElement, Wi.class);
Business business = new Business(emc);
if (!business.buildingEditAvailable(effectivePerson)) {
throw new ExceptionAccessDenied(effectivePerson);
}
Building o = emc.find(id, Building.class);
if (null == o) {
throw new ExceptionEntityNotExist(id, Building.class);
}
emc.beginTransaction(Building.class);
Wi.copier.copy(wi, o);
emc.check(o, CheckPersistType.all);
emc.commit();
Wo wo = new Wo();
wo.setId(o.getId());
result.setData(wo);
return result;
}
}
public static class Wi extends Building {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Wi, Building> copier = WrapCopierFactory.wi(Wi.class, Building.class, null,
JpaObject.FieldsInvisible);
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionGet extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Building building = emc.find(id, Building.class);
if (null == building) {
throw new ExceptionEntityNotExist(id, Building.class);
}
Wo wo = Wo.copier.copy(building);
/* 添加Room信息 */
WrapTools.setRoom(business, wo);
/* 添加将来的Meeting信息 */
WrapTools.setFutureMeeting(business, wo.getRoomList(), true);
result.setData(wo);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionList extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = business.building().list();
List<Wo> wos = Wo.copier.copy(emc.list(Building.class, ids));
WrapTools.setRoom(business, wos);
for (WrapOutBuilding wo : wos) {
WrapTools.setFutureMeeting(business, wo.getRoomList(), true);
}
SortTools.asc(wos, false, Building.name_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionListLike extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String key) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = business.building().listLike(key);
List<Wo> wos = Wo.copier.copy(emc.list(Building.class, ids));
WrapTools.setRoom(business, wos);
SortTools.asc(wos, false, Building.name_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionListLikePinyin extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String key) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = business.building().listLikePinyin(key);
List<Wo> wos = Wo.copier.copy(emc.list(Building.class, ids));
WrapTools.setRoom(business, wos);
SortTools.asc(wos, false, Building.name_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.core.entity.Building;
class ActionListPinyinInitial extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String key) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = business.building().listPinyinInitial(key);
List<Wo> wos = Wo.copier.copy(emc.list(Building.class, ids));
WrapTools.setRoom(business, wos);
SortTools.asc(wos, false, Building.name_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.DateTools;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutBuilding;
import com.x.meeting.assemble.control.wrapout.WrapOutRoom;
import com.x.meeting.core.entity.Building;
class ActionListWithStartCompleted extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String start, String completed) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Date startTime = DateTools.parse(start, DateTools.format_yyyyMMdd + " " + DateTools.format_HHmm);
Date completedTime = DateTools.parse(completed, DateTools.format_yyyyMMdd + " " + DateTools.format_HHmm);
List<String> ids = business.building().list();
List<Wo> wos = Wo.copier.copy(emc.list(Building.class, ids));
WrapTools.setRoom(business, wos);
for (WrapOutBuilding wo : wos) {
WrapTools.setFutureMeeting(business, wo.getRoomList(), true);
for (WrapOutRoom room : wo.getRoomList()) {
WrapTools.checkRoomIdle(business, room, startTime, completedTime);
}
}
SortTools.asc(wos, false, Building.name_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutBuilding {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Building, Wo> copier = WrapCopierFactory.wo(Building.class, Wo.class, null,
Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.building;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
abstract class BaseAction extends StandardJaxrsAction {
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.building;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import com.google.gson.JsonElement;
import com.x.base.core.project.annotation.JaxrsDescribe;
import com.x.base.core.project.annotation.JaxrsMethodDescribe;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.http.HttpMediaType;
import com.x.base.core.project.jaxrs.ResponseFactory;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
import com.x.base.core.project.logger.Logger;
import com.x.base.core.project.logger.LoggerFactory;
@Path("building")
@JaxrsDescribe("建筑")
public class BuildingAction extends StandardJaxrsAction {
private static Logger logger = LoggerFactory.getLogger(BuildingAction.class);
@JaxrsMethodDescribe(value = "获取Building,同时获取Building下的Room 和 Room下的将来Meeting.", action = ActionGet.class)
@GET
@Path("{id}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void get(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("id") String id) {
ActionResult<ActionGet.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionGet().execute(effectivePerson, id);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "获取所有Building 同时获取Building下的Room 和 Room下的将来Meeting.", action = ActionList.class)
@GET
@Path("list")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void list(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request) {
ActionResult<List<ActionList.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionList().execute(effectivePerson);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "列示在所有building和下属的room,和room下面将来的会议,同时判断在指定时间内room是否空闲", action = ActionListWithStartCompleted.class)
@GET
@Path("list/start/{start}/completed/{completed}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listWithStartCompleted(@Suspended final AsyncResponse asyncResponse,
@Context HttpServletRequest request, @PathParam("start") String start,
@PathParam("completed") String completed) {
ActionResult<List<ActionListWithStartCompleted.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListWithStartCompleted().execute(effectivePerson, start, completed);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "创建Building.", action = ActionCreate.class)
@POST
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void create(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
JsonElement jsonElement) {
ActionResult<ActionCreate.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionCreate().execute(effectivePerson, jsonElement);
} catch (Exception e) {
logger.error(e, effectivePerson, request, jsonElement);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "更新Building.", action = ActionEdit.class)
@PUT
@Path("{id}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void put(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("id") String id, JsonElement jsonElement) {
ActionResult<ActionEdit.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionEdit().execute(effectivePerson, id, jsonElement);
} catch (Exception e) {
logger.error(e, effectivePerson, request, jsonElement);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "删除Building.", action = ActionDelete.class)
@DELETE
@Path("{id}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void delete(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("id") String id) {
ActionResult<ActionDelete.Wo> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionDelete().execute(effectivePerson, id);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "获取拼音首字母开始的Building.", action = ActionListPinyinInitial.class)
@GET
@Path("list/pinyininitial/{key}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listPinyinInitial(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("key") String key) {
ActionResult<List<ActionListPinyinInitial.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListPinyinInitial().execute(effectivePerson, key);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "根据名称进行模糊查询.", action = ActionListLike.class)
@GET
@Path("list/like/{key}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listLike(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("key") String key) {
ActionResult<List<ActionListLike.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListLike().execute(effectivePerson, key);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "根据拼音或者首字母进行模糊查询.", action = ActionListLikePinyin.class)
@GET
@Path("/list/like/pinyin/{key}")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listLikePinyin(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request,
@PathParam("key") String key) {
ActionResult<List<ActionListLikePinyin.Wo>> result = new ActionResult<>();
EffectivePerson effectivePerson = this.effectivePerson(request);
try {
result = new ActionListLikePinyin().execute(effectivePerson, key);
} catch (Exception e) {
logger.error(e, effectivePerson, request, null);
result.error(e);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.core.entity.Meeting;
class ActionAccept extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
Meeting meeting = emc.find(id, Meeting.class);
ActionResult<Wo> result = new ActionResult<>();
/* 在被邀请参加的人员之内 */
if (meeting.getInvitePersonList().contains(effectivePerson.getDistinguishedName())) {
emc.beginTransaction(Meeting.class);
ListTools.addWithProperty(meeting, "acceptPersonList", true, effectivePerson.getDistinguishedName());
// business.organization().person().checkNameList(meeting,
// "acceptPersonList", true);
ListTools.subtractWithProperty(meeting, "rejectPersonList", effectivePerson.getDistinguishedName());
// business.organization().person().checkNameList(meeting,
// "rejectPersonList", true);
emc.check(meeting, CheckPersistType.all);
emc.commit();
MessageFactory.meeting_accept(effectivePerson.getDistinguishedName(), meeting);
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.List;
import org.apache.commons.collections4.ListUtils;
import com.google.gson.JsonElement;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
class ActionAddInvite extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id, JsonElement jsonElement) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Wi wi = this.convertToWrapIn(jsonElement, Wi.class);
Business business = new Business(emc);
Meeting meeting = emc.find(id, Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExist(id);
}
if (!business.meetingEditAvailable(effectivePerson, meeting)) {
throw new ExceptionAccessDenied(effectivePerson);
}
Room room = emc.find(meeting.getRoom(), Room.class);
if (null == room) {
throw new ExceptionRoomNotExist(wi.getRoom());
}
emc.beginTransaction(Meeting.class);
List<String> modifyInvitePersonList = ListUtils.subtract(
this.convertToPerson(business, ListTools.trim(wi.getInvitePersonList(), true, true)),
meeting.getInvitePersonList());
meeting.getInvitePersonList().addAll(modifyInvitePersonList);
emc.check(meeting, CheckPersistType.all);
emc.commit();
if (ConfirmStatus.allow.equals(meeting.getConfirmStatus())) {
for (String _s : modifyInvitePersonList) {
MessageFactory.meeting_invite(_s, meeting, room);
}
this.notifyMeetingInviteMessage(business, meeting);
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wi extends Meeting {
private static final long serialVersionUID = -4637797853096659198L;
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionAppliedCompleted extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithAppliedCompleted(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionAppliedProcessing extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithAppliedProcessing(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionAppliedWait extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithAppliedWait(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.jaxrs.meeting.BaseAction;
import com.x.meeting.core.entity.Meeting;
/**
* 会议签到
*
*/
class ActionCheckIn extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Meeting meeting = emc.find(id, Meeting.class, ExceptionWhen.not_found);
if( meeting != null ) {
emc.beginTransaction( Meeting.class );
meeting.addCheckinPerson( effectivePerson.getDistinguishedName() );
emc.check( meeting, CheckPersistType.all );
emc.commit();
}
Wo wo = new Wo();
wo.setCheckinPersonList( meeting.getCheckinPersonList());
result.setData(wo);
return result;
}
}
public static class Wo {
@FieldDescribe("已签到的人员列表")
private List<String> checkinPersonList;
public List<String> getCheckinPersonList() {
return checkinPersonList;
}
public void setCheckinPersonList(List<String> checkinPersonList) {
this.checkinPersonList = checkinPersonList;
}
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Hashtable;
import javax.imageio.ImageIO;
import javax.ws.rs.core.UriBuilder;
import org.apache.commons.codec.binary.Base64;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.config.ApplicationServer;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.logger.Audit;
import com.x.base.core.project.logger.Logger;
import com.x.base.core.project.logger.LoggerFactory;
import com.x.base.core.project.tools.StringTools;
import com.x.organization.core.entity.Bind;
class ActionCheckInCode extends BaseAction {
private static Logger logger = LoggerFactory.getLogger(ActionCheckInCode.class);
ActionResult<Wo> execute(EffectivePerson effectivePerson, String meetingId) throws Exception {
Audit audit = logger.audit(effectivePerson);
ActionResult<Wo> result = new ActionResult<>();
Wo wo = new Wo();
String meta = StringTools.uniqueToken();
ApplicationServer applicationServer = Config.currentNode().getApplication();
Boolean sslEnable = applicationServer.getSslEnable();
String host = applicationServer.getProxyHost();
int port = applicationServer.getProxyPort();
String applicationUrl = getApplicationUrl(sslEnable, host, port) + "/x_meeting_assemble_control/jaxrs/meeting/" + meetingId + "/checkin";
/** 二维码内容 */
String url = UriBuilder.fromUri(applicationUrl).build().toASCIIString();
int width = 200; // 二维码图片宽度
int height = 200; // 二维码图片高度
String format = "png";// 二维码的图片格式
Hashtable<EncodeHintType, String> hints = new Hashtable<EncodeHintType, String>();
// 内容所使用字符集编码
hints.put(EncodeHintType.MARGIN, "1");
hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.Q.toString());
BitMatrix bitMatrix = new MultiFormatWriter().encode(url, BarcodeFormat.QR_CODE, width, height, hints);
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
image.setRGB(x, y, bitMatrix.get(x, y) ? BLACK : WHITE);
}
}
Graphics2D graphics = image.createGraphics();
Image logo = ImageIO.read(new ByteArrayInputStream(Config.bindLogo()));
graphics.drawImage(logo, 68, 68, null);
graphics.dispose();
logo.flush();
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
ImageIO.write(image, format, out);
wo.setImage(Base64.encodeBase64String(out.toByteArray()));
}
wo.setMeta(meta);
result.setData(wo);
audit.log(effectivePerson.getDistinguishedName(), "认证码发送.");
return result;
}
private String getApplicationUrl(Boolean sslEnable, String host, int port) {
if( sslEnable ) {
return "https://" + host + ":" + port;
}else {
return "http://" + host + ":" + port;
}
}
private static final int BLACK = 0xFF000000;
private static final int WHITE = 0xFFFFFFFF;
public class Wo extends Bind {
private static final long serialVersionUID = -3574645735233129236L;
@FieldDescribe("Base64编码图像.")
private String image;
public String getImage() {
return image;
}
public void setImage(String image) {
this.image = image;
}
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
class ActionConfirmAllow extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(id, Meeting.class);
if (null == meeting) {
throw new ExceptionEntityNotExist(id, Meeting.class);
}
Room room = emc.find(meeting.getRoom(), Room.class);
if (null == room) {
throw new ExceptionEntityNotExist(meeting.getRoom(), Room.class);
}
if (!business.roomEditAvailable(effectivePerson, room)) {
throw new ExceptionAccessDenied(effectivePerson);
}
emc.beginTransaction(Meeting.class);
if (!business.room().checkIdle(meeting.getRoom(), meeting.getStartTime(), meeting.getCompletedTime(),
meeting.getId())) {
throw new ExceptionRoomNotAvailable("会议室:" + room.getName() + ", 已经预约.");
}
meeting.setConfirmStatus(ConfirmStatus.allow);
emc.check(meeting, CheckPersistType.all);
emc.commit();
for (String _s : meeting.getInvitePersonList()) {
MessageFactory.meeting_invite(_s, meeting, room);
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
class ActionConfirmDeny extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(id, Meeting.class);
if (null == meeting) {
throw new ExceptionEntityNotExist(id, Meeting.class);
}
Room room = emc.find(meeting.getRoom(), Room.class);
if (null == room) {
throw new ExceptionEntityNotExist(meeting.getRoom(), Room.class);
}
if (!business.roomEditAvailable(effectivePerson, room)) {
throw new ExceptionAccessDenied(effectivePerson);
}
emc.beginTransaction(Meeting.class);
// if (!business.room().checkIdle(meeting.getRoom(), meeting.getStartTime(),
// meeting.getCompletedTime(),
// meeting.getId())) {
// throw new ExceptionRoomNotAvailable("会议室:" + room.getName() + ", 已经预约.");
// }
meeting.setConfirmStatus(ConfirmStatus.deny);
emc.check(meeting, CheckPersistType.all);
emc.commit();
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import org.apache.commons.lang3.StringUtils;
import com.google.gson.JsonElement;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
class ActionCreate extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, JsonElement jsonElement) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Wi wi = this.convertToWrapIn(jsonElement, Wi.class);
Business business = new Business(emc);
Room room = emc.find(wi.getRoom(), Room.class);
if (null == room) {
throw new ExceptionRoomNotExist(wi.getRoom());
}
if (room.getAvailable() == false) {
throw new ExceptionRoomNotAvailable(room.getName());
}
Meeting meeting = Wi.copier.copy(wi);
emc.beginTransaction(Meeting.class);
meeting.setManualCompleted(false);
meeting.setAuditor(room.getAuditor());
meeting.setRoom(room.getId());
String applicant = effectivePerson.getDistinguishedName();
/** 如果是后台调用,通过流程来触发会议 */
if (effectivePerson.isCipher() && StringUtils.isNotEmpty(wi.getApplicant())) {
applicant = wi.getApplicant();
}
if (!Config.token().isInitialManager(applicant)) {
applicant = business.organization().person().get(applicant);
}
if (StringUtils.isEmpty(applicant)) {
throw new ExceptionPersonNotExist(applicant);
}
meeting.setApplicant(applicant);
if( ListTools.isNotEmpty( meeting.getInvitePersonList() )) {
for( String str : meeting.getInvitePersonList() ) {
System.out.println(">>>>>>>> before convert invitePersonList:" + str );
}
}
meeting.setInvitePersonList(this.convertToPerson(business, meeting.getInvitePersonList()));
if( ListTools.isNotEmpty( meeting.getInvitePersonList() )) {
for( String str : meeting.getInvitePersonList() ) {
System.out.println(">>>>>>>> after convert invitePersonList:" + str );
}
}
meeting.setAcceptPersonList(this.convertToPerson(business, meeting.getAcceptPersonList()));
meeting.setRejectPersonList(this.convertToPerson(business, meeting.getRejectPersonList()));
meeting.getInvitePersonList().remove(meeting.getApplicant());
// ListTools.subtractWithProperty(meeting, "invitePersonList",
// meeting.getApplicant());
if (!business.room().checkIdle(meeting.getRoom(), meeting.getStartTime(), meeting.getCompletedTime(), "")) {
throw new ExceptionRoomNotAvailable(room.getName());
}
business.estimateConfirmStatus(meeting);
emc.persist(meeting, CheckPersistType.all);
emc.commit();
if (ConfirmStatus.allow.equals(meeting.getConfirmStatus())) {
for (String _s : meeting.getInvitePersonList()) {
MessageFactory.meeting_invite(_s, meeting, room);
}
this.notifyMeetingInviteMessage(business, meeting);
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wi extends Meeting {
private static final long serialVersionUID = -4637797853096659198L;
static WrapCopier<Wi, Meeting> copier = WrapCopierFactory.wi(Wi.class, Meeting.class, null,
JpaObject.FieldsUnmodify);
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.config.StorageMapping;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.assemble.control.ThisApplication;
import com.x.meeting.core.entity.Attachment;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
class ActionDelete extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(id, Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExist(id);
}
if (!business.meetingEditAvailable(effectivePerson, meeting)) {
throw new ExceptionAccessDenied(effectivePerson.getName());
}
emc.beginTransaction(Meeting.class);
emc.beginTransaction(Attachment.class);
List<String> ids = business.attachment().listWithMeeting(meeting.getId());
for (Attachment o : emc.list(Attachment.class, ids)) {
StorageMapping mapping = ThisApplication.context().storageMappings().get(Attachment.class,
o.getStorage());
o.deleteContent(mapping);
emc.remove(o);
}
emc.remove(meeting);
emc.commit();
if (ConfirmStatus.allow.equals(meeting.getConfirmStatus())) {
if (ConfirmStatus.allow.equals(meeting.getConfirmStatus())) {
for (String _s : meeting.getInvitePersonList()) {
MessageFactory.meeting_delete(_s, meeting);
}
this.notifyMeetingInviteMessage(business, meeting);
}
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.collections4.ListUtils;
import com.google.gson.JsonElement;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.core.entity.ConfirmStatus;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
class ActionEdit extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id, JsonElement jsonElement) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Wi wi = this.convertToWrapIn(jsonElement, Wi.class);
Meeting meeting = emc.find(id, Meeting.class);
if (null == meeting) {
throw new ExceptionMeetingNotExist(id);
}
if (!business.meetingEditAvailable(effectivePerson, meeting)) {
throw new ExceptionAccessDenied(effectivePerson);
}
Room room = emc.find(wi.getRoom(), Room.class);
if (null == room) {
throw new ExceptionRoomNotExist(wi.getRoom());
}
emc.beginTransaction(Meeting.class);
List<String> modifyInvitePersonList = ListUtils.subtract(
this.convertToPerson(business, ListTools.trim(wi.getInvitePersonList(), true, true)),
meeting.getInvitePersonList());
List<String> invitePersonList = new ArrayList<>(meeting.getInvitePersonList());
invitePersonList.addAll(modifyInvitePersonList);
Wi.copier.copy(wi, meeting);
meeting.setInvitePersonList(invitePersonList);
if (!business.room().checkIdle(meeting.getRoom(), meeting.getStartTime(), meeting.getCompletedTime(),
meeting.getId())) {
throw new ExceptionRoomNotAvailable(room.getName());
}
emc.persist(meeting, CheckPersistType.all);
emc.commit();
if (ConfirmStatus.allow.equals(meeting.getConfirmStatus())) {
for (String _s : modifyInvitePersonList) {
MessageFactory.meeting_invite(_s, meeting, room);
}
this.notifyMeetingInviteMessage(business, meeting);
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wi extends Meeting {
private static final long serialVersionUID = -4637797853096659198L;
static WrapCopier<Wi, Meeting> copier = WrapCopierFactory.wi(Wi.class, Meeting.class, null,
JpaObject.FieldsUnmodify);
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionGet extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(id, Meeting.class, ExceptionWhen.not_found);
Wo wo = Wo.copier.copy(meeting);
WrapTools.setAttachment(business, wo);
WrapTools.decorate(business, wo, effectivePerson);
result.setData(wo);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionInvitedCompleted extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithInvitedCompleted(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionInvitedProcessing extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithInvitedProcessing(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionInvitedRejected extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithInvitedRejected(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionInvitedWait extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithInvitedWait(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.desc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionListComingDay extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer count) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
Date start = calendar.getTime();
calendar.add(Calendar.DAY_OF_MONTH, count);
Date end = calendar.getTime();
List<String> ids = new ArrayList<>();
if (business.isManager(effectivePerson)) {
ids = business.meeting().listWithDate(start, end);
} else {
ids = business.meeting().listWithPersonWithDate(effectivePerson.getDistinguishedName(), start, end);
}
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, false, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionListComingMonth extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer count) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
Date start = calendar.getTime();
calendar.add(Calendar.MONTH, count);
Date end = calendar.getTime();
List<String> ids = new ArrayList<>();
if (business.isManager(effectivePerson)) {
ids = business.meeting().listWithDate(start, end);
} else {
ids = business.meeting().listWithPersonWithDate(effectivePerson.getDistinguishedName(), start, end);
}
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, false, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.organization.OrganizationDefinition;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Meeting_;
import com.x.meeting.core.entity.Room;
class ActionListForwardMonth extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer monthCount) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
Date start = calendar.getTime();
calendar.set(Calendar.MONTH, monthCount);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
calendar.add(Calendar.MILLISECOND, -1);
Date end = calendar.getTime();
List<Meeting> os = this.list(effectivePerson, business, start, end);
List<Wo> wos = Wo.copier.copy(os);
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
// this.decorateRoom(business, wos);
wos = wos.stream()
.sorted(Comparator.comparing(Meeting::getStartTime, Comparator.nullsLast(Date::compareTo)))
.collect(Collectors.toList());
result.setData(wos);
return result;
}
}
// private void decorateRoom(Business business, List<Wo> wos) throws Exception {
// List<String> ids = ListTools.extractProperty(wos, Meeting.room_FIELDNAME,
// String.class, true, true);
// EntityManager em = business.entityManagerContainer().get(Room.class);
// CriteriaBuilder cb = em.getCriteriaBuilder();
// CriteriaQuery<Room> cq = cb.createQuery(Room.class);
// Root<Room> root = cq.from(Room.class);
// Predicate p = root.get(Room_.id).in(ids);
// cq.select(root).where(p);
// List<WoRoom> os = WoRoom.copier.copy(em.createQuery(cq).getResultList());
// for (Wo wo : wos) {
// wo.setWoRoom(ListTools.findWithProperty(os, Room.id_FIELDNAME,
// wo.getRoom()));
// }
// }
private List<Meeting> list(EffectivePerson effectivePerson, Business business, Date start, Date end)
throws Exception {
EntityManager em = business.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Meeting> cq = cb.createQuery(Meeting.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.startTime), start);
/** 这里两个都是startTime是对的 */
p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.startTime), end));
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
if (effectivePerson.isNotManager() && (!business.organization().person().hasRole(effectivePerson,
OrganizationDefinition.MeetingManager))) {
p = cb.and(p,
cb.or(cb.equal(root.get(Meeting_.applicant), effectivePerson.getDistinguishedName()),
cb.equal(root.get(Meeting_.auditor), effectivePerson.getDistinguishedName()),
cb.isMember(effectivePerson.getDistinguishedName(), root.get(Meeting_.invitePersonList))));
}
cq.select(root).where(p);
return em.createQuery(cq).getResultList();
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
public static class WoRoom extends Room {
private static final long serialVersionUID = -4703274623056091697L;
public static WrapCopier<Room, WoRoom> copier = WrapCopierFactory.wo(Room.class, WoRoom.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Meeting_;
import com.x.meeting.core.entity.Room;
class ActionListForwardMonthAll extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer monthCount) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
Date start = calendar.getTime();
calendar.add(Calendar.MONTH, monthCount);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
calendar.add(Calendar.MILLISECOND, -1);
Date end = calendar.getTime();
List<Meeting> os = this.list(effectivePerson, business, start, end);
List<Wo> wos = Wo.copier.copy(os);
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
// this.decorateRoom(business, wos);
wos = wos.stream()
.sorted(Comparator.comparing(Meeting::getStartTime, Comparator.nullsLast(Date::compareTo)))
.collect(Collectors.toList());
result.setData(wos);
return result;
}
}
// private void decorateRoom(Business business, List<Wo> wos) throws Exception {
// List<String> ids = ListTools.extractProperty(wos, Meeting.room_FIELDNAME,
// String.class, true, true);
// EntityManager em = business.entityManagerContainer().get(Room.class);
// CriteriaBuilder cb = em.getCriteriaBuilder();
// CriteriaQuery<Room> cq = cb.createQuery(Room.class);
// Root<Room> root = cq.from(Room.class);
// Predicate p = root.get(Room_.id).in(ids);
// cq.select(root).where(p);
// List<WoRoom> os = WoRoom.copier.copy(em.createQuery(cq).getResultList());
// for (Wo wo : wos) {
// wo.setWoRoom(ListTools.findWithProperty(os, Room.id_FIELDNAME,
// wo.getRoom()));
// }
// }
private List<Meeting> list(EffectivePerson effectivePerson, Business business, Date start, Date end)
throws Exception {
EntityManager em = business.entityManagerContainer().get(Meeting.class);
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Meeting> cq = cb.createQuery(Meeting.class);
Root<Meeting> root = cq.from(Meeting.class);
Predicate p = cb.greaterThanOrEqualTo(root.get(Meeting_.startTime), start);
/** 这里两个都是startTime是对的 */
p = cb.and(p, cb.lessThanOrEqualTo(root.get(Meeting_.startTime), end));
p = cb.and(p, cb.notEqual(root.get(Meeting_.manualCompleted), true));
cq.select(root).where(p);
return em.createQuery(cq).getResultList();
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
Wo.FieldsInvisible);
}
public static class WoRoom extends Room {
private static final long serialVersionUID = -4703274623056091697L;
public static WrapCopier<Room, WoRoom> copier = WrapCopierFactory.wo(Room.class, WoRoom.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.List;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.core.entity.Meeting;
class ActionListNext extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String id, Integer count) throws Exception {
ActionResult<List<Wo>> result = new ActionResult<>();
if (effectivePerson.isNotManager()) {
throw new ExceptionAccessDenied(effectivePerson);
}
result = this.standardListNext(Wo.copier, id, count, JpaObject.sequence_FIELDNAME, null, null, null, null, null, null, null, null,
true, DESC);
return result;
}
public static class Wo extends Meeting {
private static final long serialVersionUID = -7495725325510376323L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
@FieldDescribe("排序号")
private Long rank;
public Long getRank() {
return rank;
}
public void setRank(Long rank) {
this.rank = rank;
}
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionListOnDay extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer year, Integer month, Integer day)
throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month - 1);
calendar.set(Calendar.DAY_OF_MONTH, day);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
Date start = calendar.getTime();
/** 一天内 */
calendar.add(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MILLISECOND, -1);
Date end = calendar.getTime();
List<String> ids = new ArrayList<>();
if (business.isManager(effectivePerson)) {
ids = business.meeting().listWithDate(start, end);
} else {
ids = business.meeting().listWithPersonWithDate(effectivePerson.getDistinguishedName(), start, end);
}
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, false, "startTime");
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionListOnDayAll extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer year, Integer month, Integer day)
throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month - 1);
calendar.set(Calendar.DAY_OF_MONTH, day);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
Date start = calendar.getTime();
/** 一天内 */
calendar.add(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MILLISECOND, -1);
Date end = calendar.getTime();
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithDate(start, end);
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, false, "startTime");
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionListOnMonth extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer year, Integer month) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month - 1);
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
Date start = calendar.getTime();
/** 一个月内 */
calendar.add(Calendar.MONTH, 1);
calendar.add(Calendar.MILLISECOND, -1);
Date end = calendar.getTime();
List<String> ids = new ArrayList<>();
if (business.isManager(effectivePerson)) {
ids = business.meeting().listWithDate(start, end);
} else {
ids = business.meeting().listWithPersonWithDate(effectivePerson.getDistinguishedName(), start, end);
}
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, false, "startTime");
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionListOnMonthAll extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, Integer year, Integer month) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month - 1);
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
/** 一个月内 */
Date start = calendar.getTime();
calendar.add(Calendar.MONTH, 1);
calendar.add(Calendar.MILLISECOND, -1);
Date end = calendar.getTime();
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithDate(start, end);
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, false, "startTime");
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null, Wo.Excludes);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.List;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.annotation.FieldDescribe;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.meeting.core.entity.Meeting;
class ActionListPrev extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson, String id, Integer count) throws Exception {
ActionResult<List<Wo>> result = new ActionResult<>();
if (effectivePerson.isNotManager()) {
throw new ExceptionAccessDenied(effectivePerson);
}
result = this.standardListPrev(Wo.copier, id, count, JpaObject.sequence_FIELDNAME, null, null, null, null, null, null, null, null,
true, DESC);
return result;
}
public static class Wo extends Meeting {
private static final long serialVersionUID = -7495725325510376323L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
@FieldDescribe("排序号")
private Long rank;
public Long getRank() {
return rank;
}
public void setRank(Long rank) {
this.rank = rank;
}
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.exception.ExceptionAccessDenied;
import com.x.base.core.project.exception.ExceptionEntityNotExist;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Meeting;
class ActionManualCompleted extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Meeting meeting = emc.find(id, Meeting.class);
if (null == meeting) {
throw new ExceptionEntityNotExist(id, Meeting.class);
}
if (!business.meetingEditAvailable(effectivePerson, meeting)) {
throw new ExceptionAccessDenied(effectivePerson);
}
emc.beginTransaction(Meeting.class);
meeting.setManualCompleted(true);
emc.check(meeting, CheckPersistType.all);
emc.commit();
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.annotation.CheckPersistType;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.jaxrs.WoId;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.MessageFactory;
import com.x.meeting.core.entity.Meeting;
class ActionReject extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Meeting meeting = emc.find(id, Meeting.class, ExceptionWhen.not_found);
/* 在被邀请参加的人员之内 */
if (meeting.getInvitePersonList().contains(effectivePerson.getDistinguishedName())) {
emc.beginTransaction(Meeting.class);
ListTools.addWithProperty(meeting, "rejectPersonList", true, effectivePerson.getDistinguishedName());
ListTools.subtractWithProperty(meeting, "acceptPersonList", effectivePerson.getDistinguishedName());
emc.check(meeting, CheckPersistType.all);
emc.commit();
// this.notifyMeetingRejectMessage(business, meeting, meeting.getApplicant());
MessageFactory.meeting_reject(effectivePerson.getDistinguishedName(), meeting);
}
Wo wo = new Wo();
wo.setId(meeting.getId());
result.setData(wo);
return result;
}
}
public static class Wo extends WoId {
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionWaitAccept extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
ids = business.meeting().listWithPersonWaitAccept(effectivePerson.getDistinguishedName());
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.SortTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutMeeting;
import com.x.meeting.core.entity.Meeting;
class ActionWaitConfirm extends BaseAction {
ActionResult<List<Wo>> execute(EffectivePerson effectivePerson) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<List<Wo>> result = new ActionResult<>();
Business business = new Business(emc);
List<String> ids = new ArrayList<>();
if (business.isManager(effectivePerson)) {
ids = business.meeting().listWaitConfirm();
} else {
ids = business.meeting().listWithPersonWaitConfirm(effectivePerson.getDistinguishedName());
}
List<Wo> wos = Wo.copier.copy(emc.list(Meeting.class, ids));
WrapTools.decorate(business, wos, effectivePerson);
WrapTools.setAttachment(business, wos);
SortTools.asc(wos, Meeting.startTime_FIELDNAME);
result.setData(wos);
return result;
}
}
public static class Wo extends WrapOutMeeting {
private static final long serialVersionUID = 4609263020989488356L;
public static WrapCopier<Meeting, Wo> copier = WrapCopierFactory.wo(Meeting.class, Wo.class, null,
JpaObject.FieldsInvisible);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import java.util.ArrayList;
import java.util.List;
import com.x.base.core.project.exception.ExceptionWhen;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
import com.x.base.core.project.logger.Logger;
import com.x.base.core.project.logger.LoggerFactory;
import com.x.base.core.project.organization.OrganizationDefinition;
import com.x.base.core.project.organization.OrganizationDefinition.DistinguishedNameCategory;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.core.entity.Building;
import com.x.meeting.core.entity.Meeting;
import com.x.meeting.core.entity.Room;
abstract class BaseAction extends StandardJaxrsAction {
private static Logger logger = LoggerFactory.getLogger(BaseAction.class);
@SuppressWarnings("unused")
protected void notifyMeetingInviteMessage(Business business, Meeting meeting) throws Exception {
if (ListTools.isNotEmpty(meeting.getInvitePersonList())) {
Room room = business.entityManagerContainer().find(meeting.getRoom(), Room.class, ExceptionWhen.not_found);
Building building = business.entityManagerContainer().find(room.getBuilding(), Building.class,
ExceptionWhen.not_found);
for (String str : ListTools.nullToEmpty(meeting.getInvitePersonList())) {
logger.debug("send old meeting invite message to:{}, message body:{}", str, meeting);
// MeetingInviteMessage message = new MeetingInviteMessage(str, building.getId(), room.getId(),
// meeting.getId());
// Collaboration.send(message);
}
}
}
@SuppressWarnings("unused")
protected void notifyMeetingCancelMessage(Business business, Meeting meeting) throws Exception {
if (ListTools.isNotEmpty(meeting.getInvitePersonList())) {
Room room = business.entityManagerContainer().find(meeting.getRoom(), Room.class, ExceptionWhen.not_found);
Building building = business.entityManagerContainer().find(room.getBuilding(), Building.class,
ExceptionWhen.not_found);
for (String str : ListTools.trim(meeting.getInvitePersonList(), true, true, meeting.getApplicant())) {
// Collaboration.notification(str, "会议取消提醒.", "会议已经取消:" +
// meeting.getSubject(),
// "会议室:" + room.getName() + ",会议地点:" + building.getName() +
// building.getAddress() + ".",
// "meetingReject");
// MeetingCancelMessage message = new MeetingCancelMessage(str, building.getId(), room.getId(),
// meeting.getId());
// Collaboration.send(message);
}
}
}
@SuppressWarnings("unused")
protected void notifyMeetingAcceptMessage(Business business, Meeting meeting, String person) throws Exception {
Room room = business.entityManagerContainer().find(meeting.getRoom(), Room.class, ExceptionWhen.not_found);
Building building = business.entityManagerContainer().find(room.getBuilding(), Building.class,
ExceptionWhen.not_found);
for (String str : ListTools.trim(meeting.getInvitePersonList(), true, true, meeting.getApplicant())) {
// Collaboration.notification(str, "会议接受提醒.", person + "接受会议邀请:" +
// meeting.getSubject(),
// "会议室:" + room.getName() + ",会议地点:" + building.getName() +
// building.getAddress() + ".",
// "meetingAccept");
// MeetingAcceptMessage message = new MeetingAcceptMessage(str, building.getId(), room.getId(),
// meeting.getId());
// Collaboration.send(message);
}
}
@SuppressWarnings("unused")
protected void notifyMeetingRejectMessage(Business business, Meeting meeting, String person) throws Exception {
Room room = business.entityManagerContainer().find(meeting.getRoom(), Room.class, ExceptionWhen.not_found);
Building building = business.entityManagerContainer().find(room.getBuilding(), Building.class,
ExceptionWhen.not_found);
for (String str : ListTools.trim(meeting.getInvitePersonList(), true, true, meeting.getApplicant())) {
// MeetingRejectMessage message = new MeetingRejectMessage(str, building.getId(), room.getId(),
// meeting.getId());
// Collaboration.send(message);
}
}
protected List<String> convertToPerson(Business business, List<String> list) throws Exception {
List<String> os = new ArrayList<>();
DistinguishedNameCategory category = OrganizationDefinition.distinguishedNameCategory(list);
os.addAll(business.organization().person().list(category.getPersonList()));
os.addAll(business.organization().person().listWithIdentity(category.getIdentityList()));
os.addAll(business.organization().person().listWithUnitSubDirect(category.getUnitList()));
os.addAll(business.organization().person().list( category.getUnknownList()) );
os = ListTools.trim(os, true, true);
return os;
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.project.exception.PromptException;
class ExceptionMeetingNotExist extends PromptException {
private static final long serialVersionUID = 4132300948670472899L;
ExceptionMeetingNotExist(String flag) {
super("会议 {}, 不存在.", flag);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.project.exception.PromptException;
class ExceptionPersonNotExist extends PromptException {
private static final long serialVersionUID = 4132300948670472899L;
ExceptionPersonNotExist(String name) {
super("person:{} not exist.", name);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.project.exception.PromptException;
public class ExceptionRoomNotAvailable extends PromptException {
private static final long serialVersionUID = -6884859406782731288L;
public ExceptionRoomNotAvailable(String flag) {
super("会议室 {}, 不可用.", flag);
}
}
package com.x.meeting.assemble.control.jaxrs.meeting;
import com.x.base.core.project.exception.PromptException;
class ExceptionRoomNotExist extends PromptException {
private static final long serialVersionUID = 4132300948670472899L;
ExceptionRoomNotExist(String flag) {
super("会议室 {}, 不存在.", flag);
}
}
package com.x.meeting.assemble.control.jaxrs.openmeeting;
import org.apache.commons.lang3.BooleanUtils;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.gson.GsonPropertyObject;
import com.x.base.core.project.http.ActionResult;
public class ActionGet extends BaseAction {
public ActionResult<Wo> execute() throws Exception {
ActionResult<Wo> result = new ActionResult<>();
Wo wo = new Wo();
wo.setEnable(Config.meeting().getEnable());
/* 如果启用了再加载 */
if (BooleanUtils.isTrue(Config.meeting().getEnable())) {
wo.setHost(Config.meeting().getHost());
wo.setPort(Config.meeting().getPort());
wo.setHttpProtocol(Config.meeting().getHttpProtocol());
wo.setOauth2Id(Config.meeting().getOauth2Id());
}
result.setData(wo);
return result;
}
public static class Wo extends GsonPropertyObject {
private Boolean enable;
private String host;
private Integer port;
private String oauth2Id;
private String httpProtocol;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public Integer getPort() {
return port;
}
public void setPort(Integer port) {
this.port = port;
}
public String getOauth2Id() {
return oauth2Id;
}
public void setOauth2Id(String oauth2Id) {
this.oauth2Id = oauth2Id;
}
public Boolean getEnable() {
return enable;
}
public void setEnable(Boolean enable) {
this.enable = enable;
}
public String getHttpProtocol() {
return httpProtocol;
}
public void setHttpProtocol(String httpProtocol) {
this.httpProtocol = httpProtocol;
}
}
}
package com.x.meeting.assemble.control.jaxrs.openmeeting;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.BooleanUtils;
import com.google.gson.Gson;
import com.x.base.core.project.bean.NameIdPair;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.gson.XGsonBuilder;
import com.x.base.core.project.http.ActionResult;
public class ActionListRoom extends BaseAction {
private Gson gson = XGsonBuilder.instance();
@SuppressWarnings("unchecked")
public ActionResult<List<Wo>> execute() throws Exception {
ActionResult<List<Wo>> result = new ActionResult<>();
List<Wo> wos = new ArrayList<>();
/* 如果启用了再加载 */
if (BooleanUtils.isTrue(Config.meeting().getEnable())) {
String sid = this.login();
String address = Config.meeting().getHttpProtocol() + "://" + Config.meeting().getHost() + ":"
+ Config.meeting().getPort() + "/openmeetings/services/room/public/conference?sid=" + sid;
URL url = new URL(address);
HttpURLConnection httpUrlConnection = (HttpURLConnection) url.openConnection();
httpUrlConnection.setUseCaches(false);
httpUrlConnection.setDoOutput(false);
httpUrlConnection.setDoInput(true);
String str = "";
try (InputStream input = httpUrlConnection.getInputStream()) {
str = IOUtils.toString(input, StandardCharsets.UTF_8);
}
Map<?, ?> map = gson.fromJson(str, Map.class);
Object o = map.get("roomDTO");
if (null != o) {
for (Map<?, ?> m : (List<Map<?, ?>>) o) {
Wo wo = new Wo();
wo.setName(Objects.toString(m.get("name")));
Double d = Double.parseDouble(Objects.toString(m.get("id")));
wo.setId("" + d.intValue());
wos.add(wo);
}
}
}
result.setData(wos);
return result;
}
public static class Wo extends NameIdPair {
}
}
package com.x.meeting.assemble.control.jaxrs.openmeeting;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Objects;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import com.google.gson.Gson;
import com.x.base.core.project.config.Config;
import com.x.base.core.project.config.Meeting;
import com.x.base.core.project.gson.XGsonBuilder;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
class BaseAction extends StandardJaxrsAction {
protected Gson gson = XGsonBuilder.instance();
String login() throws Exception {
Meeting o = Config.meeting();
String address = Config.meeting().getHttpProtocol() + "://" + Config.meeting().getHost() + ":"
+ Config.meeting().getPort() + "/openmeetings/services/user/login?user=" + o.getUser() + "&pass="
+ o.getPass();
URL url = new URL(address);
HttpURLConnection httpUrlConnection = (HttpURLConnection) url.openConnection();
httpUrlConnection.setUseCaches(false);
httpUrlConnection.setDoOutput(false);
httpUrlConnection.setDoInput(true);
String str = "";
try (InputStream input = httpUrlConnection.getInputStream()) {
str = IOUtils.toString(input, StandardCharsets.UTF_8);
}
Map<?, ?> map = gson.fromJson(str, Map.class);
Map<?, ?> serviceResult = (Map<?, ?>) map.get("serviceResult");
if (StringUtils.equalsIgnoreCase("SUCCESS", Objects.toString(serviceResult.get("type")))) {
return serviceResult.get("message").toString();
}
throw new Exception("login openmeeting server error.");
}
}
package com.x.meeting.assemble.control.jaxrs.openmeeting;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import com.x.base.core.project.annotation.JaxrsMethodDescribe;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.HttpMediaType;
import com.x.base.core.project.jaxrs.ResponseFactory;
import com.x.base.core.project.jaxrs.StandardJaxrsAction;
@Path("openmeeting")
public class OpenMeetingAction extends StandardJaxrsAction {
@JaxrsMethodDescribe(value = "获取openmeeting配置.", action = ActionGet.class)
@GET
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void get(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request) {
ActionResult<ActionGet.Wo> result = new ActionResult<>();
try {
result = new ActionGet().execute();
} catch (Throwable th) {
th.printStackTrace();
result.error(th);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
@JaxrsMethodDescribe(value = "获取openmeeting的room.", action = ActionListRoom.class)
@GET
@Path("list/room")
@Produces(HttpMediaType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.APPLICATION_JSON)
public void listRoom(@Suspended final AsyncResponse asyncResponse, @Context HttpServletRequest request) {
ActionResult<List<ActionListRoom.Wo>> result = new ActionResult<>();
try {
result = new ActionListRoom().execute();
} catch (Throwable th) {
th.printStackTrace();
result.error(th);
}
asyncResponse.resume(ResponseFactory.getEntityTagActionResultResponse(request, result));
}
}
\ No newline at end of file
package com.x.meeting.assemble.control.jaxrs.room;
import com.x.base.core.container.EntityManagerContainer;
import com.x.base.core.container.factory.EntityManagerContainerFactory;
import com.x.base.core.entity.JpaObject;
import com.x.base.core.project.bean.WrapCopier;
import com.x.base.core.project.bean.WrapCopierFactory;
import com.x.base.core.project.http.ActionResult;
import com.x.base.core.project.http.EffectivePerson;
import com.x.base.core.project.tools.ListTools;
import com.x.meeting.assemble.control.Business;
import com.x.meeting.assemble.control.WrapTools;
import com.x.meeting.assemble.control.wrapout.WrapOutRoom;
import com.x.meeting.core.entity.Room;
class ActionGet extends BaseAction {
ActionResult<Wo> execute(EffectivePerson effectivePerson, String id) throws Exception {
try (EntityManagerContainer emc = EntityManagerContainerFactory.instance().create()) {
ActionResult<Wo> result = new ActionResult<>();
Business business = new Business(emc);
Room room = emc.find(id, Room.class);
Wo wo = Wo.copier.copy(room);
WrapTools.setFutureMeeting(business, wo, true);
result.setData(wo);
return result;
}
}
public static class Wo extends WrapOutRoom {
private static final long serialVersionUID = -969148596991975992L;
static WrapCopier<Room, Wo> copier = WrapCopierFactory.wo(Room.class, Wo.class, null,
ListTools.toList(JpaObject.FieldsInvisible));
}
}
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册