Statistics
| Branch: | Revision:

m2u-upass-core / src / my / com / upass / services / AssignTokenService.java @ 30:aec0089bb43e

History | View | Annotate | Download (5.25 KB)

1 0:02300db8682b hadi
/**
2
 * Copyright (c) 2010 Penril Datability (M) Sdn Bhd All rights reserved.
3
 *
4
 * This software is copyrighted. Under the copyright laws, this software
5
 * may not be copied, in whole or in part, without prior written consent
6
 * of Penril Datability (M) Sdn Bhd or its assignees. This software is
7
 * provided under the terms of a license between Penril Datability (M)
8
 * Sdn Bhd and the recipient, and its use is subject to the terms of that
9
 * license.
10
 */
11
package my.com.upass.services;
12
13
import java.util.Date;
14
15
import my.com.upass.Constants;
16
import my.com.upass.dao.DAOFactoryProvider;
17
import my.com.upass.dao.UserDAO;
18
import my.com.upass.dao.UserTokenDAO;
19
import my.com.upass.factory.UPassFactory;
20 23:1281bdc0fb8f mohd
import my.com.upass.pojo.MinimalUserBean;
21 0:02300db8682b hadi
import my.com.upass.pojo.UserTokenBean;
22
import my.com.upass.secure.metric.SecureMetricTokenControllerImpl;
23
import my.com.upass.vasco.TokenController;
24
25
/**
26
 * PROGRAMMER: Danniell
27
 * CHANGE-NO:
28
 * TASK-NO:
29
 * DATE CREATED: Dec 28, 2011
30
 * TAG AS:
31
 * REASON(S):
32
 * MODIFICATION:
33
 */
34
35
/**
36
 * <Class description>
37
 */
38
public class AssignTokenService
39
{
40
        public int assignToken(String serialNumber, String userAlias, int TargetTokenAssignmentState)
41
        {
42
                int rc = Constants.ERR_SYSTEM_NOT_READY;
43
44
                try
45
                {
46
                        UserTokenDAO tokenDao = DAOFactoryProvider.getDAOFactory ().getUserTokenDAO (UPassFactory.getTokenMode ());
47
                        UserTokenBean tb = new UserTokenBean();
48
                        String targetUserAlias = null;
49
50
                        switch (UPassFactory.getTokenMode ())
51
                        {
52
                                case GEMALTO:
53
                                case VASCO:
54
                                        if (TargetTokenAssignmentState == Constants.TKN_STATE_ASSIGNED)
55
                                        {
56
                                                // if the operation is to assign token to user, query by token serial number
57
                                                // then assign token to user
58
                                                tb = tokenDao.getTokenFromStoreBySerialNumber(serialNumber);
59
                                                targetUserAlias = userAlias;
60
                                        }
61
                                        else
62
                                        {
63
                                                // query by user ID, since it already assigned
64
                                                // then return token back to TokenOwner
65
                                                tb = tokenDao.getTokenFromStoreByUserAlias(userAlias);
66
                                                targetUserAlias = "TokenOwner";
67
                                        }
68
69
                                        if (tb == null)
70
                                        {
71
                                                return Constants.ERR_TOKEN_NOT_EXIST;
72
                                        }
73
74
                                        // check if the token already assigned and the target state is assignToken
75
                                        if (TargetTokenAssignmentState == Constants.TKN_STATE_ASSIGNED &
76
                                                        tb.getVstate() == Constants.TKN_STATE_ASSIGNED)
77
                                        {
78
                                                return Constants.ERR_TOKEN_ALREADY_ASSIGNED;
79
                                        }
80
81
                                        // check user exist for the token
82
                                        UserDAO userDao = DAOFactoryProvider.getDAOFactory ().getUserDAO ();
83 23:1281bdc0fb8f mohd
                                        MinimalUserBean ub = userDao.getUserFromStore(targetUserAlias);
84 0:02300db8682b hadi
85
                                        if (ub==null)
86
                                        {
87
                                                return Constants.ERR_USERALIAS_NOT_FOUND;
88
                                        }
89
90
                                        // reset and assign token to user
91
                                        TokenController tc = UPassFactory.getTokenController(tb);
92
                                        rc = tc.resetToken();
93
94
                                        tb = (UserTokenBean) tc.getUpdatedObject();
95
                                        tb.setVstate(TargetTokenAssignmentState);
96
                                        tb.setVdateAssigned( new Date());
97
                                        tb.setVuserID(ub.getUserID());
98
                                        tb.setVdateFirstUsed(null);
99
                                        tb.setVdateLastUsed(null);
100
101
                                        // update database
102
                                        boolean lrc = tokenDao.updateTokenToStore(tb);
103
                                        if (!lrc)
104
                                        {
105
                                                return Constants.ERR_UNKNOWN;
106
                                        }
107
108
                                        break;
109
                                case SECUREMETRIC:
110
111
                                        //TODO create TokenController Interface
112
                                        SecureMetricTokenControllerImpl impl = new SecureMetricTokenControllerImpl(tb);
113
114
                                        UserTokenBean token = new UserTokenBean();
115
116
                                        switch (TargetTokenAssignmentState){
117
118
                                                case Constants.TKN_STATE_ASSIGNED:
119
120
                                                        token = impl.getUserTokenByToken(serialNumber);
121
122
                                                        if (null != token.getVserialNumber())
123
                                                        {
124
                                                                return Constants.ERR_TOKEN_ALREADY_ASSIGNED;
125
                                                        }
126
127
128
                                                        /*
129
                                                         * Check Lock Token Status
130
                                                         * if the status is lock set to unlock before assign
131
                                                         */
132
133
                                                        rc = impl.getTokenLocked(serialNumber);
134
135
                                                        if (Constants.ERR_INVALID_CREDENTIAL == rc){
136
137
                                                                impl.setTokenLocked(serialNumber, 0);
138
                                                        }
139
140
                                                        rc =impl.assignToken(serialNumber, userAlias, 1);
141
142
                                                        if (rc != Constants.ERR_SUCCESS)
143
                                                        {
144
                                                                impl.deleteUser(userAlias);
145
                                                                if (Constants.OTPR_CORE_DB_TOKEN_NOTEXISTS == rc){
146
                                                                        return Constants.ERR_TOKEN_NOT_EXIST;
147
148
                                                                }else if (Constants.OTPR_CORE_TOKEN_BINDED == rc ){
149
                                                                                return Constants.ERR_TOKEN_ALREADY_ASSIGNED;
150
151
                                                                        }else{
152
                                                                                return Constants.ERR_UNKNOWN;
153
                                                                        }
154
                                                        }
155
156
                                                        break;
157
158
                                                case Constants.TKN_STATE_UNASSIGNED:
159
160
                                                        token = impl.getUserTokenByUserId(userAlias);
161
162
                                                        rc =impl.unassignToken(userAlias, token.getVserialNumber());
163
164
                                                        if (rc != Constants.ERR_SUCCESS){
165
166
                                                                return Constants.ERR_UNKNOWN;
167
                                                        }
168
169
                                                        rc = impl.deleteUser(userAlias);
170
171
                                                        if (rc != Constants.ERR_SUCCESS){
172
173
                                                                return Constants.ERR_UNKNOWN;
174
                                                        }
175
176
                                                        break;
177
                                                default:
178
                                                        break;
179
                                        }
180
                                default:
181
                                        break;
182
                        }
183
184
                }
185
                catch(Exception e)
186
                {
187
                        e.printStackTrace ();
188
                        return rc;
189
                }
190
191
                return Constants.ERR_SUCCESS;
192
193
        }
194
}