@RequestMapping(value = "/order/search/integral")
public void searchUserIntegralByOrder(String orderNoes, HttpServletResponse response)
throws IOException {
String[] orderNoArray = orderNoes.split("\\n");
Map<Integer, UserIntegralAndCoupon> uicMap =
new LinkedHashMap<Integer, UserIntegralAndCoupon>();
StringBuilder sbd = new StringBuilder();
for (String orderNo : orderNoArray) {
if (StringUtils.isBlank(orderNo) || NumberUtils.toLong(orderNo) <= 0) continue;
long no = NumberUtils.toLong(orderNo.trim());
Order order = tradeCenterBossClient.queryOrderByOrderNo(no);
if (order == null) continue;
User user = userService.getUserById(order.getUserId());
if (user == null || uicMap.get(user.getId()) != null) continue;
UserIntegralAndCoupon uic = new UserIntegralAndCoupon();
uic.setUserId(user.getId());
uic.setUserName(user.getUserName());
uic.setPhone(StringUtils.isNotBlank(user.getPhone()) ? user.getPhone() : "");
uic.setEmail(StringUtils.isNotBlank(user.getEmail()) ? user.getEmail() : "");
uic.setIntegral(user.getCurrency());
List<Coupon> coupons = couponService.queryCouponByUserId(order.getUserId());
sbd.delete(0, sbd.length());
int i = 0;
String str = "";
for (Coupon coupon : coupons) {
sbd.append(coupon.getCode());
if (coupon.isUsed()) str = "已使用";
else if (coupon.isExpire()) str = "已过期";
if (StringUtils.isNotBlank(str)) sbd.append("(").append(str).append(")");
if (i != coupons.size() - 1) sbd.append(", ");
i++;
}
uic.setCoupon(sbd.toString());
sbd.delete(0, sbd.length());
// 从地址中去寻找
List<Address> addresses = addressService.queryAllAddress(order.getUserId());
i = 0;
for (Address address : addresses) {
sbd.append(address.getName()).append("/").append(address.getMobile()).append("/");
sbd.append(address.getProvince()).append(address.getLocation());
if (address.isDefaultAddress()) sbd.append("<span style='color:red;'>(默认地址)</span>");
if (i != addresses.size() - 1) sbd.append("\n");
}
uic.setAddress(sbd.toString());
uicMap.put(user.getId(), uic);
}
new JsonResult(true).addData("orderList", uicMap.values()).toJson(response);
}
public synchronized void run() {
CookMessage("been started");
while (getLoggedIn()) {
Order order = WaitingOrders.poll();
if (order == null) {
// request a new order
cookClient.outQueue.OutQueue.add("CookOrderRequest");
try {
cookClient.cookGUI.setCurrentlyCooking("Awaiting new order");
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
try {
// update the gui
cookClient.cookGUI.setCurrentlyCooking(order.getOrderNumber().toString());
wait(GetRandomWaitTime());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
order.setCookedAtNow();
order.setOrderStatus(OrderStatus.cooked);
cookClient.outQueue.OutQueue.add(order); // pass back to server
}
}
// TODO: if they still have incomplete orders do something
}
public double calculateMaximumDrawdown() {
double bal = openingBalance;
double low = bal;
double high = bal;
double maxDD = 0.0;
for (Order order : orders) {
bal += order.getProfitLoss();
if (bal > high) {
high = bal;
low = bal;
} else if (bal < low) {
low = bal;
}
double dd = high - low;
if (dd > maxDD) {
maxDD = dd;
}
}
return maxDD;
}
public void orderSorting() {
for (int i = 0; i < this.order.size(); i++) {
Order order1 = this.order.get(i);
for (int p = 0; p < this.order.size(); p++) {
Order order2 = this.order.get(p);
int compare = order1.compareTo(order2);
if (compare % 10 < 2) {
int order1Index = this.order.indexOf(order1);
this.order.remove(p);
this.order.add(p, order1);
this.order.remove(order1Index);
this.order.add(order1Index, order2);
order1 = order2;
}
}
}
for (int i = 0; i < this.order.size(); i++) {
Order order1 = this.order.get(i);
for (int p = 0; p < this.order.size(); p++) {
Order order2 = this.order.get(p);
int compare = order1.compareTo(order2);
if ((compare / 1000 < 2) && (compare % 10 == 0)) {
int order1Index = this.order.indexOf(order1);
this.order.remove(p);
this.order.add(p, order1);
this.order.remove(order1Index);
this.order.add(order1Index, order2);
order1 = order2;
}
}
}
}
@Override
public View onCreateView(
LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
if (container == null) {
return null;
}
mainLayout = inflater.inflate(R.layout.full_order_fragment, null);
if (getArguments() != null) {
Date date = (Date) getArguments().getSerializable("execDate");
int orderId = getArguments().getInt("orderId", 0);
if (date != null) {
Order order = new Order();
order.setExecDate(date);
showOrder(order);
} else if (orderId != 0) {
showOrder(Order.getOrderFromBase(orderId));
}
} else {
showOrder(new Order());
}
return mainLayout;
}
public void msgNewOrder(WaiterAgent w, int tableNum, String order) {
print("msgNewOrder() from Waiter " + w.getName());
long timeFinish = -1;
if (findFood(order).amount > 0) {
timeFinish =
(System.currentTimeMillis() + (long) ((menu.menuItems.get(order)) * Constants.SECOND));
int previousInventoryAmount = inventory.get(order);
inventory.put(order, previousInventoryAmount - 1);
print("Number of items of type " + order + " left: " + inventory.get(order));
Order incomingOrder = new Order(w, tableNum, order, timeFinish);
orders.add(incomingOrder);
Food f = findFood(order);
f.amount--;
if (f.amount <= f.low) {
marketOrders.add(new MarketOrder(f.choice, f.capacity - f.amount));
f.ordered = true;
}
} else {
Order incomingOrder = new Order(w, tableNum, order, timeFinish);
incomingOrder.state = OrderState.UnableToBeSupplied;
menu.menuList.remove(order);
orders.add(incomingOrder);
Food f = findFood(order);
marketOrders.add(new MarketOrder(f.choice, f.capacity - f.amount));
}
stateChanged();
}
@Test
public void testGetMultiValueConstraints() throws Exception {
Engine engine = new Engine();
Field[] fields = engine.getClass().getDeclaredFields();
assertNotNull(fields);
assertTrue(fields.length == 1);
ReflectionHelper.setAccessibility(fields[0]);
Annotation annotation = fields[0].getAnnotation(Pattern.List.class);
assertNotNull(annotation);
List<Annotation> multiValueConstraintAnnotations =
constraintHelper.getMultiValueConstraints(annotation);
assertTrue(
multiValueConstraintAnnotations.size() == 2, "There should be two constraint annotations");
assertTrue(
multiValueConstraintAnnotations.get(0) instanceof Pattern, "Wrong constraint annotation");
assertTrue(
multiValueConstraintAnnotations.get(1) instanceof Pattern, "Wrong constraint annotation");
Order order = new Order();
fields = order.getClass().getDeclaredFields();
assertNotNull(fields);
assertTrue(fields.length == 1);
ReflectionHelper.setAccessibility(fields[0]);
annotation = fields[0].getAnnotation(NotNull.class);
assertNotNull(annotation);
multiValueConstraintAnnotations = constraintHelper.getMultiValueConstraints(annotation);
assertTrue(
multiValueConstraintAnnotations.size() == 0, "There should be no constraint annotations");
}
public void testChanged() throws Exception {
Order po = OrderMother.makeOrder();
save(po.getRestaurant());
save(po);
final Serializable orderId = po.getId();
Order detachedOrder = am.detach(po);
doWithTransaction(
new TxnCallback() {
public void execute() throws Exception {
Order po = (Order) load(Order.class, orderId.toString());
po.noteSent("msgid", new Date());
po.accept("x");
}
});
try {
Order attachedOrder = am.attach(detachedOrder);
fail("Expected exception");
} catch (OptimisticLockingFailureException e) {
}
}
public ExpressionProtos.WindowFunction toProtoBuf() {
ExpressionProtos.WindowFunction.Builder builder = ExpressionProtos.WindowFunction.newBuilder();
builder.setProject(project);
builder.setName(name);
builder.setIsDistinct(distinct);
for (ScalarExpression param : parameters) {
builder.addParameters(param.toProtoBuf());
}
for (ScalarExpression pb : partitionBy) {
builder.addPartitionBy(pb.toProtoBuf());
}
if (sortBy != null && sortBy.size() > 0) {
for (Order order : sortBy) {
builder.addOrderBy(order.toProtoBuf());
}
}
if (windowing != null) {
builder.setWindowingClause(windowing.toProtoBuf());
}
return builder.build();
}
private BigDecimal calculateTotalSalesTax() {
BigDecimal salesTax = BigDecimal.ZERO;
for (Order order : orders) {
salesTax = salesTax.add(order.calculateSalesTax());
}
return salesTax;
}
public Map<String, Object> lista(Map<String, Object> params) {
log.debug("Buscando lista de facturas con params {}", params);
if (params == null) {
params = new HashMap<>();
}
if (!params.containsKey("max")) {
params.put("max", 10);
} else {
params.put("max", Math.min((Integer) params.get("max"), 100));
}
if (params.containsKey("pagina")) {
Long pagina = (Long) params.get("pagina");
Long offset = (pagina - 1) * (Integer) params.get("max");
params.put("offset", offset.intValue());
}
if (!params.containsKey("offset")) {
params.put("offset", 0);
}
Criteria criteria = currentSession().createCriteria(FacturaAlmacen.class);
Criteria countCriteria = currentSession().createCriteria(FacturaAlmacen.class);
if (params.containsKey("almacen")) {
criteria.createCriteria("almacen").add(Restrictions.idEq(params.get("almacen")));
countCriteria.createCriteria("almacen").add(Restrictions.idEq(params.get("almacen")));
}
if (params.containsKey("filtro")) {
String filtro = (String) params.get("filtro");
Disjunction propiedades = Restrictions.disjunction();
propiedades.add(Restrictions.ilike("folio", filtro, MatchMode.ANYWHERE));
criteria.add(propiedades);
countCriteria.add(propiedades);
}
if (params.containsKey("order")) {
String campo = (String) params.get("order");
if (params.get("sort").equals("desc")) {
criteria.addOrder(Order.desc(campo));
} else {
criteria.addOrder(Order.asc(campo));
}
} else {
criteria.createCriteria("estatus").addOrder(Order.asc("prioridad"));
}
criteria.addOrder(Order.desc("fechaModificacion"));
if (!params.containsKey("reporte")) {
criteria.setFirstResult((Integer) params.get("offset"));
criteria.setMaxResults((Integer) params.get("max"));
}
params.put("facturas", criteria.list());
countCriteria.setProjection(Projections.rowCount());
params.put("cantidad", (Long) countCriteria.list().get(0));
return params;
}
@org.junit.Test()
public void testRemoveItem() throws Exception {
order.addItem(item);
int totalCount = order.total();
order.removeItem(item);
assertEquals(totalCount - order.total(), 1);
}
private BigDecimal calculateTotalAmount() {
BigDecimal totalAmount = BigDecimal.ZERO;
for (Order order : orders) {
totalAmount = totalAmount.add(order.calculateTotalAmount());
}
return totalAmount;
}
private String getOrderDetails() {
StringBuilder output = new StringBuilder();
for (Order order : orders) {
output.append(order.toString());
}
return output.toString();
}
private BigDecimal outstanding() {
BigDecimal outstanding = BigDecimal.ZERO;
for (Order order : orders) {
outstanding = outstanding.add(order.getPrice());
}
return outstanding;
}
boolean equals(Order other) {
if (other.getKind() == Kind.ANY && kind == Kind.ANY) return true;
if (kind != other.getKind()) return false;
return attrNames.equals(other.getAttrNames());
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/order/updateAdditionalInstructions.ajax", method = RequestMethod.POST)
public ResponseEntity<byte[]> updateAdditionalInstructions(
@RequestParam(value = "orderId") String orderId,
@RequestParam(value = "additionalInstructions") String additionalInstructions)
throws Exception {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Updating additional instructions for orderId: " + orderId);
}
Map<String, Object> model = new HashMap<String, Object>();
try {
Order order = orderRepository.findByOrderId(orderId);
order.setAdditionalInstructions(additionalInstructions);
order = orderRepository.saveOrder(order);
model.put("success", true);
model.put("order", order);
} catch (Exception ex) {
LOGGER.error("", ex);
model.put("success", false);
model.put("message", ex.getMessage());
}
return buildOrderResponse(model);
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/order/applyVoucher.ajax", method = RequestMethod.POST)
public ResponseEntity<byte[]> applyVoucher(
HttpServletRequest request, @RequestParam(value = "voucherId") String voucherId)
throws Exception {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Applying voucher to order");
}
Map<String, Object> model = new HashMap<String, Object>();
voucherId = voucherId == null ? "" : voucherId.trim();
try {
boolean success = true;
String reason = null;
HttpSession session = request.getSession(true);
String orderId = (String) session.getAttribute("orderid");
Order order = null;
if (orderId != null) {
order = orderRepository.findByOrderId(orderId);
}
if (order != null) {
if (order.getVoucher() != null) {
success = false;
reason = "voucher-already-applied";
} else {
Voucher voucher = voucherRepository.findByVoucherId(voucherId);
if (voucher == null) {
success = false;
reason = "voucher-not-found";
} else {
if (voucher.isUsed()) {
success = false;
reason = "voucher-already-used";
} else {
order.setVoucher(voucher);
order = orderRepository.saveOrder(order);
}
}
}
}
// Return processed status
model.put("success", success);
model.put("order", order);
model.put("reason", reason);
} catch (Exception ex) {
LOGGER.error("", ex);
model.put("success", false);
model.put("reason", "error");
model.put("message", ex.getMessage());
}
return buildOrderResponse(model);
}
public void testReceivesWithTemplates() throws Exception {
if (!isPrereqsMet("org.mule.providers.gs.GSFunctionalTestCase.testReceivesWithTemplates()")) {
return;
}
MuleClient client = new MuleClient();
Order order = new Order();
order.setProcessed(Boolean.FALSE);
client.send("gs:java://localhost/mule-space_container/mule-space?schema=cache", order, null);
Thread.sleep(2000L);
assertEquals(1, unprocessedCount);
assertEquals(0, processedCount);
client.send("gs:java://localhost/mule-space_container/mule-space?schema=cache", order, null);
Thread.sleep(1000L);
assertEquals(2, unprocessedCount);
assertEquals(0, processedCount);
order.setProcessed(Boolean.TRUE);
client.send("gs:java://localhost/mule-space_container/mule-space?schema=cache", order, null);
Thread.sleep(1000L);
assertEquals(1, processedCount);
assertEquals(2, unprocessedCount);
client.send("gs:java://localhost/mule-space_container/mule-space?schema=cache", order, null);
Thread.sleep(1000L);
assertEquals(2, processedCount);
assertEquals(2, unprocessedCount);
}
/**
* Queries the given customer's order with the given identity.
*
* @param alias the customer alias
* @param passwordHash the customer password-hash
* @param orderIdentity the order identity
* @return the customer's order
* @throws IllegalStateException if the login data is invalid
* @throws SQLException if there is a problem with the underlying JDBC connection
*/
public Order queryOrder(final String alias, final byte[] passwordHash, final long orderIdentity)
throws SQLException {
final Order order = new Order();
final Customer customer = this.queryCustomer(alias, passwordHash);
synchronized (this.connection) {
try (PreparedStatement statement = this.connection.prepareStatement(SQL_SELECT_PURCHASE)) {
statement.setLong(1, orderIdentity);
try (ResultSet resultSet = statement.executeQuery()) {
if (!resultSet.next()) throw new IllegalStateException("purchase doesn't exist.");
if (customer.getIdentity() != resultSet.getLong("customerIdentity"))
throw new IllegalStateException("purchase not created by given customer.");
order.setIdentity(resultSet.getLong("identity"));
order.setCustomerIdentity(resultSet.getLong("customerIdentity"));
order.setCreationTimestamp(resultSet.getLong("creationTimestamp"));
order.setTaxRate(resultSet.getDouble("taxRate"));
}
}
}
this.populateOrderItems(order);
return order;
}
/**
* Queries the given customer's orders.
*
* @param alias the customer alias
* @param passwordHash the customer password-hash
* @return the customer's orders
* @throws IllegalStateException if the login data is invalid
* @throws SQLException if there is a problem with the underlying JDBC connection
*/
public SortedSet<Order> queryOrders(final String alias, final byte[] passwordHash)
throws SQLException {
final SortedSet<Order> orders = new TreeSet<Order>();
final Customer customer = this.queryCustomer(alias, passwordHash);
synchronized (this.connection) {
try (PreparedStatement statement = this.connection.prepareStatement(SQL_SELECT_PURCHASES)) {
statement.setLong(1, customer.getIdentity());
try (ResultSet resultSet = statement.executeQuery()) {
while (resultSet.next()) {
final Order purchase = new Order();
purchase.setIdentity(resultSet.getLong("identity"));
purchase.setCustomerIdentity(resultSet.getLong("customerIdentity"));
purchase.setCreationTimestamp(resultSet.getLong("creationTimestamp"));
purchase.setTaxRate(resultSet.getDouble("taxRate"));
orders.add(purchase);
}
}
}
}
for (final Order purchase : orders) {
this.populateOrderItems(purchase);
}
return orders;
}
@Override
public int compare(Order o1, Order o2) {
int result = o2.price().compare(o1.price());
if (result != 0) return result;
return new Long(o1.timeStamp()).compareTo(new Long(o2.timeStamp()));
}
/**
* Cancels an order. Note that cancel requests for orders will be rejected if they are older than
* one hour, or don't target the given customer.
*
* @param alias the customer alias
* @param passwordHash the customer password-hash
* @param orderIdentity the order identity
* @throws IllegalStateException if the login data is invalid, if the order is too old, or if it
* is not targeting the given customer
* @throws SQLException if there is a problem with the underlying JDBC connection
*/
public void deleteOrder(final String alias, final byte[] passwordHash, final long orderIdentity)
throws SQLException {
final Customer customer = this.queryCustomer(alias, passwordHash);
final Order order = this.queryOrder(alias, passwordHash, orderIdentity);
if (order.getCustomerIdentity() != customer.getIdentity())
throw new IllegalStateException("purchase not created by given customer.");
if (System.currentTimeMillis() > order.getCreationTimestamp() + TimeUnit.HOURS.toMillis(1))
throw new IllegalStateException("purchase too old.");
synchronized (this.connection) {
try (PreparedStatement statement = this.connection.prepareStatement(SQL_DELETE_PURCHASE)) {
statement.setLong(1, orderIdentity);
statement.executeUpdate();
}
}
for (final OrderItem item : order.getItems()) {
synchronized (this.connection) {
try (PreparedStatement statement =
this.connection.prepareStatement(SQL_RELEASE_ARTICLE_UNITS)) {
statement.setLong(1, item.getCount());
statement.setLong(2, item.getArticleIdentity());
statement.executeUpdate();
}
}
}
}
public void update() {
for (Order o : PendingOrders) {
if (o.getClient().getStateConstant() == CCState.Approved) {
ApprovedOrders.add(PendingOrders.get(PendingOrders.indexOf(o)));
}
}
}
@SuppressWarnings("unchecked")
@ResponseBody
@RequestMapping(value = "/order/clearOrder.ajax", method = RequestMethod.POST)
public ResponseEntity<byte[]> clearOrder(
@RequestParam(value = "orderId") String orderId,
@RequestParam(value = "restaurantId") String restaurantId)
throws Exception {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Clearing order for orderId: " + orderId);
}
Map<String, Object> model = new HashMap<String, Object>();
try {
Order order = orderRepository.findByOrderId(orderId);
Restaurant restaurant = restaurantRepository.findByRestaurantId(restaurantId);
order.setRestaurant(restaurant);
order.getOrderItems().clear();
order.getOrderDiscounts().clear();
order = orderRepository.saveOrder(order);
model.put("success", true);
model.put("order", order);
} catch (Exception ex) {
LOGGER.error("", ex);
model.put("success", false);
model.put("message", ex.getMessage());
}
return buildOrderResponse(model);
}
/**
* 构造子查询sql
*
* @param table
* @param refKey
* @param ids
* @param ordersMap
* @param fieldName
* @return
*/
private String buildChildQuerySql(
String table,
String refKey,
StringBuffer ids,
Map<String, Orders> ordersMap,
String fieldName) {
StringBuffer childSql = new StringBuffer();
childSql
.append("select * from ")
.append(NameConverter.toTableName(Constants.DEFAULT_TABLE_PREFIX, table))
.append(" where ")
.append(NameConverter.toColumnName(Constants.DEFAULT_COLUMN_PREFIX, refKey))
.append(" in (");
childSql.append(ids);
childSql.append(")");
Orders orders = ordersMap.get(fieldName);
if (orders != null && orders.value().length > 0) {
childSql.append(" order by ");
for (Order order : orders.value()) {
childSql
.append(NameConverter.toColumnName(Constants.DEFAULT_COLUMN_PREFIX, order.key()))
.append(" ")
.append(order.order())
.append(",");
}
childSql.deleteCharAt(childSql.length() - 1);
}
return childSql.toString();
}
public boolean hasField(String attributeName) {
for (Order order : this.orders) {
if (order.getAttr().equals(attributeName)) {
return true;
}
}
return false;
}
public Order findOrder(String orderNumber) {
for (Order o : orders) {
if (o.getOrderNumber().equals(orderNumber)) {
return o;
}
}
return null;
}
public static Order parseConceptReferenceCode(String code) {
for (Order candidate : values()) {
if (candidate.getCodeInEmrConceptSource().equals(code)) {
return candidate;
}
}
return null;
}
private void createOrder5(Customer customer) {
Order order = new Order();
order.setCustomer(customer);
order.addShipment(new OrderShipment());
Ebean.save(order);
}
