Subversion Repositories SmartDukaan

Rev

Rev 3390 | Rev 3405 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3137 mandeep.dh 1 
/**
2 
 *
3 
 */
4 
package in.shop2020.serving.controllers;
5 
 
3339 mandeep.dh 6 
import in.shop2020.crm.Activity;
7 
import in.shop2020.crm.ActivityType;
3137 mandeep.dh 8 
import in.shop2020.crm.Agent;
3390 mandeep.dh 9 
import in.shop2020.crm.SearchFilter;
3137 mandeep.dh 10 
import in.shop2020.crm.Ticket;
3339 mandeep.dh 11 
import in.shop2020.crm.TicketCategory;
12 
import in.shop2020.crm.TicketPriority;
3137 mandeep.dh 13 
import in.shop2020.crm.TicketStatus;
14 
import in.shop2020.model.v1.user.User;
15 
import in.shop2020.model.v1.user.UserContextException;
3390 mandeep.dh 16 
import in.shop2020.serving.auth.CRMAuthorizingRealm;
17 
import in.shop2020.thrift.clients.CRMClient;
18 
import in.shop2020.thrift.clients.UserClient;
3137 mandeep.dh 19 
 
3397 mandeep.dh 20 
import java.text.ParseException;
3137 mandeep.dh 21 
import java.util.ArrayList;
3390 mandeep.dh 22 
import java.util.Collections;
3137 mandeep.dh 23 
import java.util.List;
24 
 
25 
import org.apache.thrift.TException;
26 
 
27 
/**
28 
 * @author mandeep
29 
 *
30 
 */
31 
public class TicketsController extends BaseController {
32 
 
33 
    /**
34 
     *
35 
     */
36 
    private static final long serialVersionUID = 1L;
37 
 
38 
    List<Ticket>              tickets          = new ArrayList<Ticket>();
3339 mandeep.dh 39 
    private String            userEmailId;
40 
    private String            description;
41 
    private String            assigneeEmailId;
42 
    private String            priority;
43 
    private String            category;
44 
    private String            orderId;
3397 mandeep.dh 45 
    private String[]          agentIds;
46 
    private String            startTimestamp;
47 
    private String            endTimestamp;
3137 mandeep.dh 48 
 
3339 mandeep.dh 49 
    public String create() {
50 
        try {
3390 mandeep.dh 51 
            long creatorId = CRMAuthorizingRealm.getAgent(currentAgentEmailId).getId();
3339 mandeep.dh 52 
            Ticket ticket = new Ticket();
53 
            ticket.setDescription(description);
54 
            ticket.setCreatorId(creatorId);
55 
            ticket.setStatus(TicketStatus.OPEN);
56 
            ticket.setPriority(TicketPriority.valueOf(priority));
57 
            ticket.setCategory(TicketCategory.valueOf(category));
58 
 
59 
            Activity activity = new Activity();
60 
            // At creation of ticket activity's description is same as that of
61 
            // ticket
62 
            activity.setDescription("Creating Ticket");
63 
            activity.setType(ActivityType.OTHER);
64 
            activity.setTicketPriority(TicketPriority.valueOf(priority));
65 
            activity.setTicketStatus(TicketStatus.OPEN);
66 
            activity.setCreatorId(creatorId);
67 
            activity.setTicketCategory(TicketCategory.valueOf(category));
68 
            activity.setTicketDescription(description);
69 
 
70 
            if (orderId != null && !orderId.isEmpty()) {
71 
                ticket.setOrderId(Long.parseLong(orderId));
72 
            }
73 
 
74 
            if (userEmailId != null && !userEmailId.isEmpty()) {
3390 mandeep.dh 75 
                User user = null;
76 
                userContextServiceClient = new UserClient().getClient();
77 
                try {
78 
                    user = userContextServiceClient.getUserByEmail(userEmailId);
79 
                } catch (UserContextException e) {
80 
                    log.error("Could not fetch user for " + userEmailId, e);
81 
                }
82 
 
83 
                if (user != null && user.getUserId() != -1) {
84 
                    ticket.setCustomerId(user.getUserId());
85 
                    activity.setCustomerId(user.getUserId());
86 
                }
87 
                else {
88 
                    ticket.setCustomerEmailId(userEmailId);
89 
                    activity.setCustomerEmailId(userEmailId);
90 
                }
3339 mandeep.dh 91 
            }
92 
 
93 
            // handling null values appropriately
94 
            if (assigneeEmailId != null && !assigneeEmailId.isEmpty()) {
3390 mandeep.dh 95 
                long assigneeId = CRMAuthorizingRealm.getAgent(assigneeEmailId).getId();
3339 mandeep.dh 96 
                ticket.setAssigneeId(assigneeId);
97 
                activity.setTicketAssigneeId(assigneeId);
98 
            }
99 
 
3390 mandeep.dh 100 
            crmServiceClient         = new CRMClient().getClient();
3339 mandeep.dh 101 
            crmServiceClient.insertTicket(ticket, activity);
102 
        } catch (TException e) {
103 
            log.error("Error while creating ticket", e);
104 
            return EXCEPTION;
105 
        }
106 
 
107 
        return getMyOpenTickets();
108 
    }
109 
 
3397 mandeep.dh 110 
    public String searchTickets() throws ParseException {
3137 mandeep.dh 111 
        try {
3397 mandeep.dh 112 
            SearchFilter searchFilter = new SearchFilter();
113 
            if (agentIds != null && agentIds.length != 0) {
114 
                searchFilter.setTicketAssigneeIds(new ArrayList<Long>());
115 
                for (String agentId : agentIds) {
116 
                    searchFilter.getTicketAssigneeIds().add(CRMAuthorizingRealm.getAgent(agentId).getId());
117 
                }
118 
            }
3137 mandeep.dh 119 
 
3397 mandeep.dh 120 
            if (startTimestamp != null && !startTimestamp.isEmpty()) {
121 
                searchFilter.setStartTimestamp(SDF.parse(startTimestamp).getTime());
122 
            }
123 
 
124 
            if (endTimestamp != null && !endTimestamp.isEmpty()) {
125 
                searchFilter.setEndTimestamp(SDF.parse(endTimestamp).getTime());
126 
            }
127 
 
3390 mandeep.dh 128 
            crmServiceClient         = new CRMClient().getClient();
129 
            for (Ticket ticket : crmServiceClient.getTickets(searchFilter)) {
3137 mandeep.dh 130 
                if (TicketStatus.OPEN.equals(ticket.getStatus())) {
131 
                    tickets.add(ticket);
132 
                }
133 
            }
134 
        } catch (TException e) {
135 
            String errorString = "Error getting tickets for "
136 
                    + currentAgentEmailId;
137 
            log.error(errorString, e);
138 
            addActionError(errorString);
139 
        }
140 
 
141 
        return INDEX;
142 
    }
143 
 
3397 mandeep.dh 144 
    public String getMyOpenTickets() {
3137 mandeep.dh 145 
        try {
3390 mandeep.dh 146 
            Agent agent = CRMAuthorizingRealm.getAgent(currentAgentEmailId);
147 
 
148 
            SearchFilter searchFilter = new SearchFilter();
149 
            searchFilter.setTicketAssigneeIds(Collections.singletonList(agent.getId()));
150 
            crmServiceClient         = new CRMClient().getClient();
3397 mandeep.dh 151 
            for (Ticket ticket : crmServiceClient.getTickets(searchFilter)) {
152 
                if (TicketStatus.OPEN.equals(ticket.getStatus())) {
153 
                    tickets.add(ticket);
154 
                }
155 
            }
3137 mandeep.dh 156 
        } catch (TException e) {
3339 mandeep.dh 157 
            String errorString = "Error getting tickets for "
158 
                    + currentAgentEmailId;
3137 mandeep.dh 159 
            log.error(errorString, e);
160 
            addActionError(errorString);
161 
        }
162 
 
163 
        return INDEX;
164 
    }
165 
 
166 
    public String getUnassignedTickets() {
167 
        try {
3390 mandeep.dh 168 
            crmServiceClient         = new CRMClient().getClient();
3137 mandeep.dh 169 
            tickets = crmServiceClient.getUnassignedTickets();
170 
        } catch (TException e) {
3339 mandeep.dh 171 
            String errorString = "Error getting tickets for "
172 
                    + currentAgentEmailId;
3137 mandeep.dh 173 
            log.error(errorString, e);
174 
            addActionError(errorString);
175 
        }
176 
 
177 
        return INDEX;
178 
    }
179 
 
180 
    public User getUser(Long userId) {
181 
        User user = null;
182 
 
183 
        try {
3390 mandeep.dh 184 
            userContextServiceClient = new UserClient().getClient();
3137 mandeep.dh 185 
            user = userContextServiceClient.getUserById(userId);
186 
        } catch (UserContextException e) {
187 
            String errorString = "Could not fetch user for " + userId;
188 
            log.error(errorString, e);
189 
            addActionError(errorString);
190 
        } catch (TException e) {
191 
            String errorString = "Could not create client";
192 
            log.error(errorString, e);
193 
            addActionError(errorString);
194 
        }
195 
 
196 
        return user;
197 
    }
198 
 
3390 mandeep.dh 199 
    public Agent getAgent(long agentId) throws TException {
200 
        return CRMAuthorizingRealm.getAgent(agentId);
3137 mandeep.dh 201 
    }
202 
 
3339 mandeep.dh 203 
    public List<Agent> getAllAgents() {
3390 mandeep.dh 204 
        return CRMAuthorizingRealm.getAgents();
3339 mandeep.dh 205 
    }
206 
 
207 
    public TicketCategory[] getTicketCategories() {
208 
        return TicketCategory.values();
209 
    }
210 
 
211 
    public TicketPriority[] getTicketPriorities() {
212 
        return TicketPriority.values();
213 
    }
214 
 
3137 mandeep.dh 215 
    public List<Ticket> getTickets() {
216 
        return tickets;
217 
    }
218 
 
219 
    public void setTickets(List<Ticket> tickets) {
220 
        this.tickets = tickets;
221 
    }
3339 mandeep.dh 222 
 
223 
    public String getUserEmailId() {
224 
        return userEmailId;
225 
    }
226 
 
227 
    public void setUserEmailId(String userEmailId) {
228 
        this.userEmailId = userEmailId;
229 
    }
230 
 
231 
    public String getDescription() {
232 
        return description;
233 
    }
234 
 
235 
    public void setDescription(String description) {
236 
        this.description = description;
237 
    }
238 
 
239 
    public String getAssigneeEmailId() {
240 
        return assigneeEmailId;
241 
    }
242 
 
243 
    public void setAssigneeEmailId(String assigneeEmailId) {
244 
        this.assigneeEmailId = assigneeEmailId;
245 
    }
246 
 
247 
    public String getPriority() {
248 
        return priority;
249 
    }
250 
 
251 
    public void setPriority(String priority) {
252 
        this.priority = priority;
253 
    }
254 
 
255 
    public String getCategory() {
256 
        return category;
257 
    }
258 
 
259 
    public void setCategory(String category) {
260 
        this.category = category;
261 
    }
262 
 
263 
    public String getOrderId() {
264 
        return orderId;
265 
    }
266 
 
267 
    public void setOrderId(String orderId) {
268 
        this.orderId = orderId;
269 
    }
3397 mandeep.dh 270 
 
271 
    public String[] getAgentIds() {
272 
        return agentIds;
273 
    }
274 
 
275 
    public void setAgentIds(String[] agentIds) {
276 
        this.agentIds = agentIds;
277 
    }
278 
 
279 
    public String getStartTimestamp() {
280 
        return startTimestamp;
281 
    }
282 
 
283 
    public void setStartTimestamp(String startTimestamp) {
284 
        this.startTimestamp = startTimestamp;
285 
    }
286 
 
287 
    public String getEndTimestamp() {
288 
        return endTimestamp;
289 
    }
290 
 
291 
    public void setEndTimestamp(String endTimestamp) {
292 
        this.endTimestamp = endTimestamp;
293 
    }
3137 mandeep.dh 294 
}