Example usage for org.joda.time.format DateTimeFormatter parseDateTime

List of usage examples for org.joda.time.format DateTimeFormatter parseDateTime

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.format.*
  5. DateTimeFormatter
  6. parseDateTime

Introduction

In this page you can find the example usage for org.joda.time.format DateTimeFormatter parseDateTime.

Prototype

public DateTime parseDateTime(String text)

Source Link

Document

Parses a date-time from the given text, returning a new DateTime.

Usage

From source file:com.claresco.tinman.sql.XapiStatementSQLReader.java

License:Open Source License

private ArrayList<Integer> executeConjQueryStatement(HashMap<String, String> paramMaps,
        HashMap<String, Integer> locationMaps, String conjQueryStatement)
        throws SQLException, XapiSQLOperationProblemException {
    PreparedStatement myConjQueryStatement = myConn.prepareStatement(conjQueryStatement);
    DateTimeFormatter theFormatter = ISODateTimeFormat.dateTimeParser();
    for (String paramName : paramMaps.keySet()) {
        String paramValue = paramMaps.get(paramName);
        int locationIndex = locationMaps.get(paramName).intValue();
        if (paramName.equals("statementId")) {
            myConjQueryStatement.setString(locationIndex, paramValue);
        } else if (paramName.equals("agent")) {

            myConjQueryStatement.setInt(locationIndex, Integer.parseInt(paramValue));
        } else if (paramName.equals("verb")) {
            myConjQueryStatement.setString(locationIndex, paramValue);
        } else if (paramName.equals("activity")) {
            myConjQueryStatement.setString(locationIndex, paramValue);
        } else if (paramName.equals("since")) {
            try {
                DateTime myTimeStamp = theFormatter.parseDateTime(paramValue);
                Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
                myConjQueryStatement.setTimestamp(locationIndex, SQLUtility.getTimestamp(myTimeStamp), cal);
            } catch (IllegalArgumentException exc) {
                throw new XapiSQLOperationProblemException("Having trouble reading the timestamp");
            }/*from   w ww  . ja v  a  2s .c om*/
        } else if (paramName.equals("until")) {
            try {
                DateTime myTimeStamp = theFormatter.parseDateTime(paramValue);
                Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
                myConjQueryStatement.setTimestamp(locationIndex, SQLUtility.getTimestamp(myTimeStamp), cal);
            } catch (IllegalArgumentException exc) {
                throw new XapiSQLOperationProblemException("Having trouble parsing the timestamp");
            }
        }
    }

    myConjQueryStatement.setInt(locationMaps.get("isvoided").intValue(), 0);

    myResult = myConjQueryStatement.executeQuery();

    ArrayList<Integer> arrayIDs = new ArrayList<Integer>();

    while (myResult.next()) {
        arrayIDs.add(new Integer(myResult.getInt("statementid")));
    }

    if (arrayIDs.isEmpty()) {
        return null;
    }

    return arrayIDs;
}

From source file:com.clevercloud.bianca.lib.date.DateModule.java

License:Open Source License

/**
 * Returns the parsed date.// w ww  .j  av a  2 s . c o  m
 */
public Value strptime(Env env, String date, String format) {
    ArrayValueImpl array = new ArrayValueImpl();
    DateTimeFormatterBuilder fb = new DateTimeFormatterBuilder();

    int length = format.length();

    for (int i = 0; i < length; i++) {
        char ch = format.charAt(i);
        if (ch != '%') {
            fb.appendLiteral(ch);
            continue;
        }

        switch (format.charAt(++i)) {
        case 'a':
            fb.appendDayOfWeekShortText();
            break;

        case 'A':
            fb.appendDayOfWeekText();
            break;

        case 'h':
        case 'b':
            fb.appendMonthOfYearShortText();
            ;
            break;

        case 'B':
            fb.appendMonthOfYearText();
            break;

        // TODO: case 'c'

        case 'C':
            fb.appendCenturyOfEra(2, 2);
            break;

        case 'd':
            fb.appendDayOfMonth(2);
            break;

        case 'D':
            fb.appendMonthOfYear(2);
            fb.appendLiteral('/');
            fb.appendDayOfMonth(2);
            fb.appendLiteral('/');
            fb.appendYear(2, 2);
            break;

        // TODO: case 'e'

        case 'F':
            fb.appendYear(4, 4);
            fb.appendLiteral('-');
            fb.appendMonthOfYear(2);
            fb.appendLiteral('-');
            fb.appendDayOfMonth(2);
            break;

        // TODO: case 'g'
        // TODO: case 'G'

        case 'H':
            fb.appendHourOfDay(2);
            break;

        case 'I':
            fb.appendHourOfHalfday(2);
            break;

        case 'j':
            fb.appendDayOfYear(3);
            break;

        // TODO: case 'l'

        case 'm':
            fb.appendMonthOfYear(2);
            break;

        case 'M':
            fb.appendMinuteOfHour(2);
            break;

        case 'n':
            fb.appendLiteral("\n");
            break;

        case 'p':
        case 'P':
            fb.appendHalfdayOfDayText();
            break;

        case 'r':
            fb.appendHourOfHalfday(2);
            fb.appendLiteral(':');
            fb.appendMinuteOfHour(2);
            fb.appendLiteral(':');
            fb.appendSecondOfMinute(2);
            fb.appendLiteral(' ');
            fb.appendHalfdayOfDayText();
            break;

        case 'R':
            fb.appendHourOfDay(2);
            fb.appendLiteral(':');
            fb.appendMinuteOfHour(2);
            break;

        // TODO: case 's'

        case 'S':
            fb.appendSecondOfMinute(2);
            break;

        case 't':
            fb.appendLiteral("\t");
            break;

        case 'T':
            fb.appendHourOfDay(2);
            fb.appendLiteral(':');
            fb.appendMinuteOfHour(2);
            fb.appendLiteral(':');
            fb.appendSecondOfMinute(2);
            break;

        // TODO: case 'u'
        // TODO: case 'U'
        // TODO: case 'V'
        // TODO: case 'w'
        // TODO: case 'W'
        // TODO: case 'x'
        // TODO: case 'X'

        case 'y':
            fb.appendYear(2, 2);
            break;

        case 'Y':
            fb.appendYear(4, 4);
            break;

        case 'z':
            fb.appendTimeZoneOffset(null, true, 2, 2);
            break;

        case 'Z':
            fb.appendTimeZoneName();
            break;

        case '%':
            fb.appendLiteral('%');
            break;

        default:
            fb.appendLiteral(ch);
        }
    }

    DateTimeFormatter dtf = fb.toFormatter().withLocale(Locale.getDefault()).withOffsetParsed();

    org.joda.time.DateTime dt = new org.joda.time.DateTime();

    String unparsed = "";

    try {
        dt = dtf.parseDateTime(date);
    } catch (IllegalArgumentException e) {
        String delims = "[\"]+";

        String[] splits = e.getMessage().split(delims);

        unparsed = unparsed.concat(splits[3]);
    }

    // According to manual strptime(3)
    if (dt.getCenturyOfEra() == 0) {
        if (dt.getYear() > 68) {
            dt = dt.withCenturyOfEra(19);
        } else {
            dt = dt.withCenturyOfEra(20);
        }
    }

    array.put("tm_sec", dt.getSecondOfMinute());
    array.put("tm_min", dt.getMinuteOfHour());
    array.put("tm_hour", dt.getHourOfDay());
    array.put("tm_mday", dt.getDayOfMonth());
    array.put("tm_mon", dt.getMonthOfYear() - 1);
    array.put("tm_year", dt.getYearOfCentury() + ((dt.getCenturyOfEra() - 19) * 100)); // Years since 1900
    array.put("tm_wday", dt.getDayOfWeek() % 7);
    array.put("tm_yday", dt.getDayOfYear() - 1);
    array.put("unparsed", unparsed);

    return array;
}

From source file:com.cloudhopper.commons.util.DateTimeUtil.java

License:Apache License

/**
 * Parses a string for an embedded date and/or time contained within a
 * string such as "app.2008-05-01.log" or "app-20090624-051112.log.gz".
 * This method accepts a variety of date and time patterns that are valid
 * within the Joda DateTime library.  For example, the string "app.2008-05-01.log"
 * would be a pattern of "yyyy-MM-dd" and the string "app-20090624-151112.log.gz"
 * would be a pattern of "yyyy-MM-dd-HHmmss".
 * @param string0 The string to parse/*from ww w.  j av a  2s. c  o  m*/
 * @param pattern The DateTime pattern embedded in the string such as
 *      "yyyy-MM-dd".  The pattern must be a valid DateTime Joda pattern.
 * @param zone The timezone the parsed date will be in
 * @return The parsed DateTime value
 * @throws IllegalArgumentException Thrown if the pattern is invalid or if
 *      string did not contain an embedded date.
 */
public static DateTime parseEmbedded(String string0, String pattern, DateTimeZone zone)
        throws IllegalArgumentException {
    // compile a date time formatter -- which also will check that pattern
    DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern).withZone(zone);

    //
    // use the pattern to generate a regular expression now -- we'll do a
    // simple replacement of ascii characters with \\d
    //
    StringBuilder regex = new StringBuilder(pattern.length() * 2);
    for (int i = 0; i < pattern.length(); i++) {
        char c = pattern.charAt(i);
        if (Character.isLetter(c)) {
            regex.append("\\d");
        } else {
            regex.append(c);
        }
    }

    // extract the date from the string
    Pattern p = Pattern.compile(regex.toString()); // Compiles regular expression into Pattern.
    Matcher m = p.matcher(string0); // Creates Matcher with subject s and Pattern p.

    if (!m.find()) {
        // if we get here, then no valid grouping was found
        throw new IllegalArgumentException(
                "String '" + string0 + "' did not contain an embedded date [regexPattern='" + regex.toString()
                        + "', datePattern='" + pattern + "']");
    }

    //logger.debug("Matching date: " + m.group());
    // this group represents a string in the format YYYY-MM-DD
    String dateString = m.group();
    // parse the string and return the Date
    return fmt.parseDateTime(dateString);
}

From source file:com.clustercontrol.hub.util.CollectStringDataParser.java

License:Open Source License

/**
 * ????????????//from   w  w w.  ja  va2s. c o  m
 * 
 * @param data
 * @return
 */
public CollectStringData parse(CollectStringData data) {
    Map<String, CollectDataTag> tagMap = new HashMap<>();
    for (CollectDataTag tag : data.getTagList()) {
        tagMap.put(tag.getKey(), tag);
    }

    if (isNullOrZeroLength(format.getTimestampRegex()) && isNullOrZeroLength(format.getTimestampFormat())) {
        // do nothing, use currentTimeMillis as timestamp
    } else {
        Matcher m = timestampPattern.matcher(data.getValue());
        if (m.find() && m.groupCount() > 0) {
            String timestampStr = m.group(1);

            try {
                DateTime datetime = timestampFormatter.parseDateTime(timestampStr);

                if (datetime.year().get() == 0) {
                    // for messages without year, like syslog

                    DateTime now = new DateTime();
                    DateTimeFormatter timestampFormatterWithCurrentYear = timestampFormatter
                            .withDefaultYear(now.year().get());
                    DateTimeFormatter timestampFormatterWithLastYear = timestampFormatter
                            .withDefaultYear(now.year().get() - 1);

                    datetime = timestampFormatterWithCurrentYear.parseDateTime(timestampStr);
                    if (datetime.getMillis() - now.getMillis() > 1000 * 60 * 60 * 24 * 7) {
                        // treat messages as end of year (threshold : 1 week)
                        datetime = timestampFormatterWithLastYear.parseDateTime(timestampStr);
                    }
                }

                tagMap.put(CollectStringTag.TIMESTAMP_IN_LOG.name(), new CollectDataTag(
                        new CollectDataTagPK(data.getCollectId(), data.getDataId(),
                                CollectStringTag.TIMESTAMP_IN_LOG.name()),
                        CollectStringTag.TIMESTAMP_IN_LOG.valueType(), Long.toString(datetime.getMillis())));
            } catch (IllegalArgumentException e) {
                log.warn(String.format("invalid timestamp string : format = %s, string = %s",
                        format.getTimestampRegex(), timestampStr));
            }
        }
    }

    for (LogFormatKey keyword : format.getKeyPatternList()) {
        Pattern p = keywordPatternMap.get(keyword.getKey());
        if (null == p) {
            log.debug(String.format("Pattern is null keyword : pattern=%s", keyword.getPattern()));
            continue;
        }

        Matcher m = p.matcher(data.getValue());
        String matchedStr = null;
        switch (keyword.getKeyType()) {
        case parsing:
            if (m.find() && m.groupCount() > 0) {
                matchedStr = m.group(1);
            }
            break;
        case fixed:
            if (m.find()) {
                matchedStr = keyword.getValue();
            }
            break;
        }

        if (matchedStr != null && keyword.getValueType() == ValueType.string) {
            tagMap.put(keyword.getKey(),
                    new CollectDataTag(
                            new CollectDataTagPK(data.getCollectId(), data.getDataId(), keyword.getKey()),
                            keyword.getValueType(), matchedStr));
        } else if (matchedStr != null && keyword.getValueType() != ValueType.string) {
            tagMap.put(keyword.getKey(),
                    new CollectDataTag(
                            new CollectDataTagPK(data.getCollectId(), data.getDataId(), keyword.getKey()),
                            keyword.getValueType(), matchedStr));

            switch (keyword.getValueType()) {
            case number:
                try {
                    new BigDecimal(matchedStr);
                } catch (NumberFormatException e) {
                    log.warn(String.format("not match number format : value=%s, source=%s, pattern=%s",
                            matchedStr, data.getValue(), p.pattern()));
                }
                break;
            case bool:
                if (!"true".equalsIgnoreCase(matchedStr) || !"false".equalsIgnoreCase(matchedStr)) {
                    log.warn(String.format("not match boolean type : value=%s, source=%s, pattern=%s",
                            matchedStr, data.getValue(), p.pattern()));
                }
                break;
            default:
                log.warn(String.format("unexpected value type : type=%s, value=source=%s, pattern=%s",
                        keyword.getValueType().name(), data.getValue(), p.pattern()));
                break;
            }
        }
    }

    data.setTagList(new ArrayList<>(tagMap.values()));
    return data;
}

From source file:com.coderoad.automation.common.util.DateUtil.java

License:Open Source License

/**
 * Gets the calendar./*from w ww  .ja va  2  s.c  o m*/
 * 
 * @param dateTime the date time
 * @param pattern the pattern
 * @return the calendar
 * @throws ParseException the parse exception
 */
public static Calendar getCalendar(final String dateTime, String pattern) throws ParseException {

    DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
    DateTime dt = fmt.parseDateTime(dateTime);
    return dt.toCalendar(Locale.ENGLISH);
}

From source file:com.coderoad.automation.common.util.DateUtil.java

License:Open Source License

/**
 * Parses the to utc calendar./* www . ja  v a  2 s  .  co  m*/
 * 
 * @param timestamp the timestamp
 * @param pattern the pattern
 * @return the calendar
 */
public static Calendar parseToUTCCalendar(String timestamp, String pattern) {

    DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
    fmt = fmt.withZoneUTC();
    DateTime dt = fmt.parseDateTime(timestamp);
    dt = dt.toDateTime(DateTimeZone.UTC);
    return dt.toCalendar(Locale.ENGLISH);
}

From source file:com.coderoad.automation.common.util.DateUtil.java

License:Open Source License

/**
 * Parses the to utc date.// ww  w . ja  va2  s.c  o m
 * 
 * @param timestamp the timestamp
 * @param pattern the pattern
 * @return the date
 */
public static Date parseToUTCDate(String timestamp, String pattern) {

    DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
    fmt = fmt.withZoneUTC();
    Date date = fmt.parseDateTime(timestamp).toDate();
    return date;
}

From source file:com.coderoad.automation.common.util.DateUtil.java

License:Open Source License

/**
 * Parses the to utcms.// w  w  w .j  a  va  2 s . co  m
 * 
 * @param timestamp the timestamp
 * @param pattern the pattern
 * @return the long
 */
public static Long parseToUTCMS(String timestamp, String pattern) {

    DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
    fmt = fmt.withZoneUTC();
    Date date = fmt.parseDateTime(timestamp).toDate();
    return date.getTime();
}

From source file:com.confighub.core.utils.DateTimeUtils.java

License:Open Source License

public static Date parseISO8601Date(String dateString, Date cutoff) throws ConfigException {
    if (Utils.isBlank(dateString))
        return null;

    try {/*from   ww w . j av a2s . com*/
        DateTimeFormatter parser = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ssZ");
        DateTime dt = parser.parseDateTime(dateString);
        dt = dt.toDateTime(DateTimeZone.UTC);
        Date date = dt.toDate();

        if (null != cutoff && date.before(cutoff))
            return cutoff;

        return date;
    } catch (Exception e) {
        throw new ConfigException(Error.Code.DATE_API_FORMAT_ERROR);
    }
}

From source file:com.csys.gcm.servlet.Consultation.java

/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods./*from   ww  w.  j a va2s .  c  o m*/
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException, DatatypeConfigurationException, ParseException {
    response.setContentType("text/html;charset=UTF-8");
    try (PrintWriter out = response.getWriter()) {

        if (WS.PortCltWS == null) {
            webservice = new WS();
            webservice.GcmEventWS();
        }

        Gson gson = new GsonBuilder().serializeNulls().create();
        HttpSession session = request.getSession(true);
        SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy");
        org.joda.time.format.DateTimeFormatter sdftime = DateTimeFormat.forPattern("dd/MM/yyyy HH:mm:ss");
        String function = request.getParameter("function");
        String type = request.getParameter("type");

        if (type.equals("consult")) {
            switch (function) {
            case "GetListMotif": {
                out.println(gson.toJson(WS.PortCltWS.getListMotif()));
                break;
            }
            case "GetListDiagnostic": {
                out.println(gson.toJson(WS.PortCltWS.getListDiagnostic()));
                break;
            }
            case "GetListAntecedents": {
                out.println(gson.toJson(WS.PortCltWS.getListAntecedents()));
                break;
            }
            case "GetListActe": {
                out.println(gson.toJson(WS.PortCltWS.getListActe()));
                break;
            }
            case "GetMaxActe": {
                out.println(gson.toJson(WS.PortCltWS.getMaxActe()));
                break;
            }
            case "GetListActeNonRemborsable": {
                out.println(gson.toJson(WS.PortCltWS.getListActeNonRemborsable()));
                break;
            }
            case "GetActeNonRemborsablebyLibelle": {
                String libelle = request.getParameter("libelle");
                out.println(gson.toJson(WS.PortCltWS.getActeNonRemborsablebyLibelle(libelle)));
                break;
            }
            case "GetListRdvByNumMedecin": {
                int numMedecinTrait = Integer.parseInt(request.getParameter("numMedecinTrait"));
                out.println(gson.toJson(WS.PortCltWS.getListRdvByNumMedecin(numMedecinTrait)));
                break;
            }
            case "GetListAntecedentsByPatient": {
                int patient = Integer.parseInt(request.getParameter("patient"));
                out.println(gson.toJson(WS.PortCltWS.getListAntecedentsByPatient(patient)));
                break;
            }
            case "GetListConsultationByPatient": {
                int NumFichPatient = Integer.parseInt(request.getParameter("NumFichPatient"));
                out.println(gson.toJson(WS.PortCltWS.getListConsultationByPatient(NumFichPatient)));
                break;
            }
            case "GetListPatientByFichPatient": {
                int code_Med_Trit = Integer.parseInt(request.getParameter("code_Med_Trit"));
                int NumFichPatient = Integer.parseInt(request.getParameter("NumFichPatient"));
                out.println(
                        gson.toJson(WS.PortCltWS.getListPatientByFichPatient(code_Med_Trit, NumFichPatient)));
                break;
            }
            case "GetListMotifConsultByNumConsult": {
                int NumConsult = Integer.parseInt(request.getParameter("NumConsult"));
                out.println(gson.toJson(WS.PortCltWS.getListMotifConsultByNumConsult(NumConsult)));
                break;
            }
            case "GetListActeMedicauxAllByNumConsult": {
                int NumConsult = Integer.parseInt(request.getParameter("NumConsult"));
                out.println(gson.toJson(WS.PortCltWS.getListActeMedicauxAllByNumConsult(NumConsult)));
                break;
            }
            case "GetListActeMedicauxByNumConsult": {
                int NumConsult = Integer.parseInt(request.getParameter("NumConsult"));
                out.println(gson.toJson(WS.PortCltWS.getListActeMedicauxByNumConsult(NumConsult)));
                break;
            }
            case "GetListActeMedicauxNonRembByNumConsult": {
                int NumConsult = Integer.parseInt(request.getParameter("NumConsult"));
                out.println(gson.toJson(WS.PortCltWS.getListActeMedicauxNonRembByNumConsult(NumConsult)));
                break;
            }
            case "GetConsultationByNum": {
                int num_consult = Integer.parseInt(request.getParameter("num_consult"));
                out.println(gson.toJson(WS.PortCltWS.getConsultationByNum(num_consult)));
                break;
            }
            case "GetListPrescriptionOrdByNumOrd": {
                int Num_Ord = Integer.parseInt(request.getParameter("Num_Ord"));
                out.println(gson.toJson(WS.PortCltWS.getListPrescriptionOrdByNumOrd(Num_Ord)));
                break;
            }
            case "GetExamenByNumExamen": {
                int NumConsult = Integer.parseInt(request.getParameter("NumConsult"));
                out.println(gson.toJson(WS.PortCltWS.getExamenByNumExamen(NumConsult)));
                break;
            }
            case "GetOrdonnanceByNum": {
                int num_consult = Integer.parseInt(request.getParameter("num_consult"));
                out.println(gson.toJson(WS.PortCltWS.getOrdonnanceByNum(num_consult)));
                break;
            }
            default:
                break;
            }
        } else if (type.equals("update")) {
            switch (function) {
            case "AjAntecedent": {
                String typ = request.getParameter("typ");
                String descp = request.getParameter("descp");
                int patient = Integer.parseInt(request.getParameter("patient"));
                out.println(gson.toJson(WS.PortCltWS.ajAntecedent(typ, descp, patient)));
                break;
            }
            case "SuppAntecedentByPatient": {
                int patient = Integer.parseInt(request.getParameter("patient"));
                out.println(gson.toJson(WS.PortCltWS.suppAntecedentByPatient(patient)));
                break;
            }
            case "SuppPrescriptionOrdByNum_Ord": {
                int num_ord = Integer.parseInt(request.getParameter("num_ord"));
                out.println(gson.toJson(WS.PortCltWS.suppPrescriptionOrdByNumOrd(num_ord)));
                break;
            }
            case "SuppOrdonnance": {
                String num_ord = request.getParameter("num_ord");
                out.println(gson.toJson(WS.PortCltWS.suppOrdonnance(num_ord)));
                break;
            }
            case "AjExamen": {
                String TA = request.getParameter("TA");
                String pouls = request.getParameter("pouls");
                String temp = request.getParameter("temp");
                String exam_phy = request.getParameter("exam_phy");
                String etat_general = request.getParameter("etat_general");
                String auscu_cardi = request.getParameter("auscu_cardi");
                String auscu_pleuro = request.getParameter("auscu_plo");
                String examen_ORL = request.getParameter("examen_ORL");
                String aires_gangl = request.getParameter("aires_gangl");
                String examen_abdominal = request.getParameter("examen_abdominal");

                int num_consult = Integer.parseInt(request.getParameter("num_consult"));
                out.println(gson.toJson(WS.PortCltWS.ajExamen(TA, pouls, temp, exam_phy, etat_general,
                        auscu_cardi, auscu_pleuro, examen_ORL, aires_gangl, examen_abdominal, num_consult)));
                break;
            }
            case "UpdateExamen": {
                String TA = request.getParameter("TA");
                String pouls = request.getParameter("pouls");
                String temp = request.getParameter("temp");
                String exam_phy = request.getParameter("exam_phy");
                String etat_general = request.getParameter("etat_general");
                String auscu_cardi = request.getParameter("auscu_cardi");
                String auscu_plo = request.getParameter("auscu_plo");
                String examen_ORL = request.getParameter("examen_ORL");
                String aires_gangl = request.getParameter("aires_gangl");
                String examen_abdominal = request.getParameter("examen_abdominal");

                int num_consult = Integer.parseInt(request.getParameter("num_consult"));
                out.println(gson.toJson(WS.PortCltWS.updateExamen(TA, pouls, temp, exam_phy, etat_general,
                        auscu_cardi, auscu_plo, examen_ORL, aires_gangl, examen_abdominal, num_consult)));
                break;
            }
            case "AjConsultation": {
                String date_consult = request.getParameter("date_consult");
                Date datnaiss = sdf.parse(date_consult);
                GregorianCalendar c = new GregorianCalendar();
                c.setTime(datnaiss);
                XMLGregorianCalendar dateC = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
                int num_patient = Integer.parseInt(request.getParameter("num_patient"));
                int Diag_consult = Integer.parseInt(request.getParameter("Diag_consult"));
                int code_Med_Trit = Integer.parseInt(request.getParameter("code_Med_Trit"));
                String type_consult = request.getParameter("type_consult");
                int num_examen = Integer.parseInt(request.getParameter("num_examen"));
                int num_ord = Integer.parseInt(request.getParameter("num_ord"));

                out.println(gson.toJson(WS.PortCltWS.ajConsultation(dateC, num_patient, Diag_consult,
                        type_consult, code_Med_Trit, num_examen, num_ord)));
                break;
            }
            case "AjRdv": {
                String start_date = request.getParameter("start_date");
                DateTime start_date_ = sdftime.parseDateTime(start_date);
                GregorianCalendar c = start_date_.toGregorianCalendar();
                XMLGregorianCalendar date1 = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);

                String end_date = request.getParameter("end_date");
                DateTime end_date_ = sdftime.parseDateTime(end_date);
                GregorianCalendar c1 = end_date_.toGregorianCalendar();
                XMLGregorianCalendar date2 = DatatypeFactory.newInstance().newXMLGregorianCalendar(c1);

                int num_patient = Integer.parseInt(request.getParameter("num_patient"));
                int num_medecin_trait = Integer.parseInt(request.getParameter("num_medecin_trait"));
                String typeRDV = request.getParameter("typeRDV");
                String descpRDV = request.getParameter("descpRDV");
                int presence = Integer.parseInt(request.getParameter("presence"));

                out.println(gson.toJson(WS.PortCltWS.ajRdv(date1, typeRDV, descpRDV, presence, num_patient,
                        num_medecin_trait, date2)));
                break;
            }
            case "UpdateRdv": {
                String start_date = request.getParameter("start_date");
                DateTime start_date_ = sdftime.parseDateTime(start_date);
                GregorianCalendar c = start_date_.toGregorianCalendar();
                XMLGregorianCalendar date1 = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);

                String end_date = request.getParameter("end_date");
                DateTime end_date_ = sdftime.parseDateTime(end_date);
                GregorianCalendar c1 = end_date_.toGregorianCalendar();
                XMLGregorianCalendar date2 = DatatypeFactory.newInstance().newXMLGregorianCalendar(c1);

                int num_patient = Integer.parseInt(request.getParameter("num_patient"));
                int numRdv = Integer.parseInt(request.getParameter("numRdv"));
                String typeRDV = request.getParameter("typeRDV");
                String descpRDV = request.getParameter("descpRDV");
                int presence = Integer.parseInt(request.getParameter("presence"));

                out.println(gson.toJson(WS.PortCltWS.updateRdv(numRdv, date1, typeRDV, descpRDV, presence,
                        num_patient, date2)));
                break;
            }
            case "AjOrdonnance": {
                String date_Ord = request.getParameter("date_Ord");
                Date date_Ordn = sdf.parse(date_Ord);
                GregorianCalendar c = new GregorianCalendar();
                c.setTime(date_Ordn);
                XMLGregorianCalendar dateOrd = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
                int num_ord = Integer.parseInt(request.getParameter("num_ord"));

                out.println(gson.toJson(WS.PortCltWS.ajOrdonnance(dateOrd, num_ord)));
                break;
            }
            case "AjPrescriptionOrd": {
                int num_medc = Integer.parseInt(request.getParameter("num_medc"));
                int num_ord = Integer.parseInt(request.getParameter("num_ord"));
                String dure = request.getParameter("dure");
                String qunt_med = request.getParameter("qunt_med");
                String nb_fois_util = request.getParameter("nb_fois_util");

                out.println(gson.toJson(
                        WS.PortCltWS.ajPrescriptionOrd(num_medc, num_ord, dure, qunt_med, nb_fois_util)));
                break;
            }
            case "UpdateConsultationOrd": {
                int num_Consult = Integer.parseInt(request.getParameter("num_Consult"));
                int num_ord = Integer.parseInt(request.getParameter("num_ord"));

                out.println(gson.toJson(WS.PortCltWS.updateConsultationOrd(num_Consult, num_ord)));
                break;
            }
            case "UpdateConsultation": {
                String date_consult = request.getParameter("date_consult");
                Date datnaiss = sdf.parse(date_consult);
                GregorianCalendar c = new GregorianCalendar();
                c.setTime(datnaiss);
                XMLGregorianCalendar dateC = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
                int num_Consult = Integer.parseInt(request.getParameter("num_Consult"));
                int num_patient = Integer.parseInt(request.getParameter("num_patient"));
                int Diag_consult = Integer.parseInt(request.getParameter("Diag_consult"));
                String type_consult = request.getParameter("type_consult");

                out.println(gson.toJson(WS.PortCltWS.updateConsultation(num_Consult, dateC, num_patient,
                        Diag_consult, type_consult)));
                break;
            }
            case "AjMotifConsult": {
                int num_Motif = Integer.parseInt(request.getParameter("num_Motif"));
                int num_consult = Integer.parseInt(request.getParameter("num_consult"));

                out.println(gson.toJson(WS.PortCltWS.ajMotifConsult(num_Motif, num_consult)));
                break;
            }
            case "AjActe": {
                String libelle = request.getParameter("libelle");
                int accord = Integer.parseInt(request.getParameter("accord"));
                String tiket_moder = request.getParameter("tiket_moder");
                String montant = request.getParameter("montant");
                String Description = request.getParameter("Description");
                String cotation = request.getParameter("cotation");
                String type_acte = request.getParameter("type_acte");

                out.println(gson.toJson(WS.PortCltWS.ajActe(libelle, accord, tiket_moder, montant, Description,
                        cotation, type_acte)));
                break;
            }
            case "AjParametre": {

                String date_naiss = request.getParameter("date_naiss");
                Date datnaiss_ = sdf.parse(date_naiss);
                GregorianCalendar c = new GregorianCalendar();
                c.setTime(datnaiss_);
                XMLGregorianCalendar dateC = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);

                String nom_medecin = request.getParameter("nom_medecin");
                String prenom_medecin = request.getParameter("prenom_medecin");
                String salutation = request.getParameter("salutation");
                String num_inscp_ord_med = request.getParameter("num_inscp_ord_med");
                String adresse = request.getParameter("adresse");
                String ville = request.getParameter("ville");
                String Fixe = request.getParameter("Fixe");
                String GSM = request.getParameter("GSM");
                String email = request.getParameter("email");
                String titre = request.getParameter("titre");
                String specialite = request.getParameter("specialite");
                String code_convent = request.getParameter("code_convent");
                String type_consult = request.getParameter("type_consult");
                String mnt_consultSansConv = request.getParameter("mnt_consultSansConv");
                String gouvernorat = request.getParameter("gouvernorat");
                int code_Med_Trit = Integer.parseInt(request.getParameter("code_Med_Trit"));
                double tiket_moder = Double.parseDouble(request.getParameter("tiket_moder"));
                double tva_consult = Double.parseDouble(request.getParameter("tva_consult"));
                double montant_consult = Double.parseDouble(request.getParameter("montant_consult"));

                out.println(gson.toJson(WS.PortCltWS.ajParametre(nom_medecin, prenom_medecin, dateC, salutation,
                        num_inscp_ord_med, adresse, ville, Fixe, GSM, email, titre, specialite, gouvernorat,
                        code_convent, tiket_moder, tva_consult, montant_consult, type_consult,
                        mnt_consultSansConv, code_Med_Trit)));
                break;
            }
            case "UpdateParametre": {

                String date_naiss = request.getParameter("date_naiss");
                Date datnaiss_ = sdf.parse(date_naiss);
                GregorianCalendar c = new GregorianCalendar();
                c.setTime(datnaiss_);
                XMLGregorianCalendar dateC = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);

                String nom_medecin = request.getParameter("nom_medecin");
                String prenom_medecin = request.getParameter("prenom_medecin");
                String salutation = request.getParameter("salutation");
                String num_inscp_ord_med = request.getParameter("num_inscp_ord_med");
                String adresse = request.getParameter("adresse");
                String ville = request.getParameter("ville");
                String Fixe = request.getParameter("Fixe");
                String GSM = request.getParameter("GSM");
                String email = request.getParameter("email");
                String titre = request.getParameter("titre");
                String specialite = request.getParameter("specialite");
                String code_convent = request.getParameter("code_convent");
                String type_consult = request.getParameter("type_consult");
                String mnt_consultSansConv = request.getParameter("mnt_consultSansConv");
                String gouvernorat = request.getParameter("gouvernorat");
                int num_cab = Integer.parseInt(request.getParameter("num_cab"));
                double tiket_moder = Double.parseDouble(request.getParameter("tiket_moder"));
                double tva_consult = Double.parseDouble(request.getParameter("tva_consult"));
                double montant_consult = Double.parseDouble(request.getParameter("montant_consult"));

                out.println(gson.toJson(WS.PortCltWS.updateParametre(num_cab, nom_medecin, prenom_medecin,
                        dateC, salutation, num_inscp_ord_med, adresse, ville, Fixe, GSM, email, titre,
                        specialite, gouvernorat, code_convent, tiket_moder, tva_consult, montant_consult,
                        type_consult, mnt_consultSansConv)));
                break;
            }
            case "AjActeMedicaux": {
                String date_acte = request.getParameter("date_acte");
                Date date_acte_ = sdf.parse(date_acte);
                GregorianCalendar c = new GregorianCalendar();
                c.setTime(date_acte_);
                XMLGregorianCalendar dateacte = DatatypeFactory.newInstance().newXMLGregorianCalendar(c);
                int num_acte = Integer.parseInt(request.getParameter("num_acte"));
                int num_consult = Integer.parseInt(request.getParameter("num_consult"));
                int nb_pr_chg = Integer.parseInt(request.getParameter("nb_pr_chg"));

                out.println(
                        gson.toJson(WS.PortCltWS.ajActeMedicaux(num_acte, num_consult, dateacte, nb_pr_chg)));
                break;
            }
            case "SuppConsultation": {
                String num_consult = request.getParameter("num_consult");

                out.println(gson.toJson(WS.PortCltWS.suppConsultation(num_consult)));
                break;
            }
            case "SuppRdv": {
                String num_RDV = request.getParameter("num_RDV");
                out.println(gson.toJson(WS.PortCltWS.suppRdv(num_RDV)));
                break;
            }
            case "SuppMotifConsultbyNum_Consult": {
                int num_consult = Integer.parseInt(request.getParameter("num_consult"));

                out.println(gson.toJson(WS.PortCltWS.suppMotifConsultbyNumConsult(num_consult)));
                break;
            }
            case "SuppActeMedicaux": {
                String num_consult = request.getParameter("num_consult");
                String num_acte = request.getParameter("num_acte");

                out.println(gson.toJson(WS.PortCltWS.suppActeMedicaux(num_acte, num_consult)));
                break;
            }
            case "SuppActeMedicauxbyNum_Consult": {
                int num_consult = Integer.parseInt(request.getParameter("num_consult"));

                out.println(gson.toJson(WS.PortCltWS.suppActeMedicauxbyNumConsult(num_consult)));
                break;
            }
            case "UpdateActeMedicauxbyNum_Consult": {
                int num_consult_old = Integer.parseInt(request.getParameter("num_consult_old"));
                int num_consult_New = Integer.parseInt(request.getParameter("num_consult_New"));

                out.println(gson
                        .toJson(WS.PortCltWS.updateActeMedicauxbyNumConsult(num_consult_old, num_consult_New)));
                break;
            }
            default:
                break;
            }
        }
    }
}