WebSVN – SmartDukaan – Diff – /trunk/ThriftConfig/src/main/java/in/shop2020/utils/HelperService.java

      * @param role
      */
     public List<Report> getReports(long role) throws TException;
     /**
-     * Returns the CatalogDashboardUser struct associated with the given username and password if they match.
+     * Returns the CatalogDashboardUser struct associated with the given username, password and role if they match.
      * Throws an exception otherwise.
+     *
      * @param username
      * @param password
+     * @param role
      */
-    public CatalogDashboardUser authenticateCatalogUser(String username, String password) throws HelperServiceException, TException;
+    public CatalogDashboardUser authenticateCatalogUser(String username, String password, long role) throws HelperServiceException, TException;
+  }
   public static class Client implements Iface {
     public Client(TProtocol prot)
         return result.success;
+      }
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "getReports failed: unknown result");
+    }
-    public CatalogDashboardUser authenticateCatalogUser(String username, String password) throws HelperServiceException, TException
+    public CatalogDashboardUser authenticateCatalogUser(String username, String password, long role) throws HelperServiceException, TException
+    {
-      send_authenticateCatalogUser(username, password);
+      send_authenticateCatalogUser(username, password, role);
       return recv_authenticateCatalogUser();
+    }
-    public void send_authenticateCatalogUser(String username, String password) throws TException
+    public void send_authenticateCatalogUser(String username, String password, long role) throws TException
+    {
       oprot_.writeMessageBegin(new TMessage("authenticateCatalogUser", TMessageType.CALL, seqid_));
       authenticateCatalogUser_args args = new authenticateCatalogUser_args();
       args.username = username;
       args.password = password;
+      args.role = role;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
         authenticateCatalogUser_args args = new authenticateCatalogUser_args();
         args.read(iprot);
         iprot.readMessageEnd();
         authenticateCatalogUser_result result = new authenticateCatalogUser_result();
         try {
-          result.success = iface_.authenticateCatalogUser(args.username, args.password);
+          result.success = iface_.authenticateCatalogUser(args.username, args.password, args.role);
         } catch (HelperServiceException hse) {
           result.hse = hse;
         } catch (Throwable th) {
           LOGGER.error("Internal error processing authenticateCatalogUser", th);
           TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing authenticateCatalogUser");
   public static class authenticateCatalogUser_args implements TBase<authenticateCatalogUser_args._Fields>, java.io.Serializable, Cloneable, Comparable<authenticateCatalogUser_args>   {
     private static final TStruct STRUCT_DESC = new TStruct("authenticateCatalogUser_args");
     private static final TField USERNAME_FIELD_DESC = new TField("username", TType.STRING, (short)1);
     private static final TField PASSWORD_FIELD_DESC = new TField("password", TType.STRING, (short)2);
+    private static final TField ROLE_FIELD_DESC = new TField("role", TType.I64, (short)3);
     private String username;
     private String password;
+    private long role;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
       USERNAME((short)1, "username"),
-      PASSWORD((short)2, "password");
+      PASSWORD((short)2, "password"),
+      ROLE((short)3, "role");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
         return _fieldName;
+      }
+    }
     // isset id assignments
+    private static final int __ROLE_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.USERNAME, new FieldMetaData("username", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRING)));
       put(_Fields.PASSWORD, new FieldMetaData("password", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.STRING)));
+      put(_Fields.ROLE, new FieldMetaData("role", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.I64)));
     }});
     static {
       FieldMetaData.addStructMetaDataMap(authenticateCatalogUser_args.class, metaDataMap);
+    }
     public authenticateCatalogUser_args() {
+    }
     public authenticateCatalogUser_args(
       String username,
-      String password)
+      String password,
+      long role)
+    {
       this();
       this.username = username;
       this.password = password;
+      this.role = role;
+      setRoleIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public authenticateCatalogUser_args(authenticateCatalogUser_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
       if (other.isSetUsername()) {
         this.username = other.username;
+      }
       if (other.isSetPassword()) {
         this.password = other.password;
+      }
+      this.role = other.role;
+    }
     public authenticateCatalogUser_args deepCopy() {
       return new authenticateCatalogUser_args(this);
+    }
       if (!value) {
         this.password = null;
+      }
+    }
+    public long getRole() {
+      return this.role;
+    }
+    public authenticateCatalogUser_args setRole(long role) {
+      this.role = role;
+      setRoleIsSet(true);
+      return this;
+    }
+    public void unsetRole() {
+      __isset_bit_vector.clear(__ROLE_ISSET_ID);
+    }
+    /** Returns true if field role is set (has been asigned a value) and false otherwise */
+    public boolean isSetRole() {
+      return __isset_bit_vector.get(__ROLE_ISSET_ID);
+    }
+    public void setRoleIsSet(boolean value) {
+      __isset_bit_vector.set(__ROLE_ISSET_ID, value);
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case USERNAME:
         if (value == null) {
           unsetUsername();
         } else {
           setPassword((String)value);
+        }
         break;
+      case ROLE:
+        if (value == null) {
+          unsetRole();
+        } else {
+          setRole((Long)value);
+        }
+        break;
+      }
+    }
     public void setFieldValue(int fieldID, Object value) {
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
         return getUsername();
       case PASSWORD:
         return getPassword();
+      case ROLE:
+        return new Long(getRole());
+      }
       throw new IllegalStateException();
+    }
     public Object getFieldValue(int fieldId) {
       switch (field) {
       case USERNAME:
         return isSetUsername();
       case PASSWORD:
         return isSetPassword();
+      case ROLE:
+        return isSetRole();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
           return false;
         if (!this.password.equals(that.password))
           return false;
+      }
+      boolean this_present_role = true;
+      boolean that_present_role = true;
+      if (this_present_role || that_present_role) {
+        if (!(this_present_role && that_present_role))
+          return false;
+        if (this.role != that.role)
+          return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
+      }
       lastComparison = TBaseHelper.compareTo(password, typedOther.password);
       if (lastComparison != 0) {
         return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetRole()).compareTo(isSetRole());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(role, typedOther.role);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
       return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
                 this.password = iprot.readString();
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+            case ROLE:
+              if (field.type == TType.I64) {
+                this.role = iprot.readI64();
+                setRoleIsSet(true);
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
           iprot.readFieldEnd();
+        }
+      }
       iprot.readStructEnd();
       if (this.password != null) {
         oprot.writeFieldBegin(PASSWORD_FIELD_DESC);
         oprot.writeString(this.password);
         oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(ROLE_FIELD_DESC);
+      oprot.writeI64(this.role);
+      oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
         sb.append("null");
       } else {
         sb.append(this.password);
+      }
       first = false;
+      if (!first) sb.append(", ");
+      sb.append("role:");
+      sb.append(this.role);
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws TException {

Subversion Repositories SmartDukaan

(root)/trunk/ThriftConfig/src/main/java/in/shop2020/utils/HelperService.java – Rev 2024 → 2357