import com.orm.query.Condition; //导入依赖的package包/类
@Override
public void fetchUnusedQuotes(final Category category, final Callback<List<Quote>> callback) {
    Condition [] conditions = new Condition[2];
    conditions[0] = Condition.prop(NamingHelper.toSQLNameDefault("used")).eq("0");
    conditions[1] = Condition.prop(NamingHelper.toSQLNameDefault("category")).eq(category.getId());
    final List<Quote> unusedQuotesFromCategory = Select.from(Quote.class).where(conditions).list();
    if (unusedQuotesFromCategory != null && !unusedQuotesFromCategory.isEmpty()) {
        callback.onSuccess(unusedQuotesFromCategory);
    } else if (category.source == Category.Source.BRAINY_QUOTE) {
        fetchNewQuotes(category, new Callback<List<Quote>>() {
            @Override
            public void onSuccess(List<Quote> quotes) {
                callback.onSuccess(quotes);
            }

            @Override
            public void onError(LWQError error) {
                callback.onError(error);
            }
        });
    } else {
        // It's not an error, just no return.
        callback.onSuccess(new ArrayList<Quote>());
    }
}
 

import com.orm.query.Condition; //导入依赖的package包/类
void bindTo(UserAlbum userAlbum) {
    boundTo = userAlbum;
    imageSourceName.setText(userAlbum.name);
    imageSourceName.setFocusable(true);
    imageSourceName.setFocusableInTouchMode(true);
    removeSource.setVisibility(View.VISIBLE);
    useImageSource.setChecked(userAlbum.active);
    imageSource.setImageBitmap(
            ImageLoader.getInstance().loadImageSync(
                    Select.from(UserPhoto.class)
                            .where (
                                Condition.prop(
                                        NamingHelper.toSQLNameDefault("album")
                                ).eq(userAlbum)
                            ).first().uri)
            );
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public Observable<Object> deleteStory(Story item) {
    return Observable.create(subscriber -> {
        SugarTransactionHelper.doInTansaction(() -> {
            Select.from(Story.class)
                  .where(Condition.prop(StringUtil.toSQLName("mStoryId"))
                                  .eq(item.getStoryId()))
                  .first()
                  .delete();

            StoryDetail storyDetail = Select.from(StoryDetail.class)
                                            .where(Condition.prop(StringUtil.toSQLName(StoryDetail.STORY_DETAIL_ID))
                                                            .eq(item.getStoryId()))
                                            .first();
            Select.from(Comment.class)
                  .where(Condition.prop(StringUtil.toSQLName("mStoryDetail"))
                                  .eq(storyDetail.getId()))
                  .first()
                  .delete();
            storyDetail.delete();
            if (!subscriber.isUnsubscribed()) {
                subscriber.onCompleted();
            }
        });
    });
}
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Finds transport mode by name.
 * @param name name of the transport mode to be searched
 * @return transport mode with the given name
 */
public static TransportMode getByName(String name) {
    List<TransportMode> modes = Select.from(TransportMode.class)
            .where(Condition.prop("name").eq(name))
            .limit("1")
            .list();

    return modes.get(0);
}
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Returns a list of routesearches where the nearestKnownLocation matches the given one.
 *
 * @param startLocation StartLocation of the routesearches
 * @return List of routesearches
 */
public static List<RouteSearch> getRouteSearchesByStartlocation(String startLocation) {
    return Select.from(RouteSearch.class)
            .where(Condition.prop("startlocation").eq(startLocation))
            .orderBy("timestamp DESC")
            .list();
}
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Returns a list of routesearches where the destination matches the given one.
 *
 * @param destination destination of the routesearches
 * @return List of routesearches
 */
public static List<RouteSearch> getRouteSearchesByDestination(String destination) {
    return Select.from(RouteSearch.class)
            .where(Condition.prop("destination").eq(destination))
            .orderBy("timestamp DESC")
            .list();
}
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Returns a list of routesearches where the startlocation and destination matches the given ones.
 *
 * @param startLocation Start location of the routesearch
 * @param destination Destination of the routesearch
 * @return List of routesearches
 */
public static List<RouteSearch> getRouteSearchesByStartlocationAndDestination(String startLocation, String destination) {
    return Select.from(RouteSearch.class)
            .where(Condition.prop("startlocation").eq(startLocation))
            .where(Condition.prop("destination").eq(destination))
            .orderBy("timestamp DESC")
            .list();
}
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Retrieves all RouteSearches with the given mode
 * @param mode 0 for intracity, 1 for intercity
 * @return list of routeSearches
 */
public static List<RouteSearch> getAll(int mode) {
    return Select.from(RouteSearch.class)
            .where(Condition.prop("mode").eq(mode))
            .orderBy("timestamp DESC")
            .list();
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static void incrementAppCount(String packageName, String name) {
    String identifier = AppPersistent.generateIdentifier(packageName, name);
    AppPersistent appPersistent = Select.from(AppPersistent.class).where(Condition.prop(NamingHelper.toSQLNameDefault("mIdentifier")).eq(identifier)).first();
    if (appPersistent != null) {
        appPersistent.setOpenCount(appPersistent.getOpenCount() + 1);
        appPersistent.save();
    } else {
        AppPersistent newAppPersistent = new AppPersistent(packageName, name, DEFAULT_OPEN_COUNT, DEFAULT_ORDER_NUMBER, DEFAULT_APP_VISIBILITY);
        newAppPersistent.save();
    }
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static void setAppOrderNumber(String packageName, String name, int orderNumber) {
    String identifier = AppPersistent.generateIdentifier(packageName, name);
    AppPersistent appPersistent = Select.from(AppPersistent.class).where(Condition.prop(NamingHelper.toSQLNameDefault("mIdentifier")).eq(identifier)).first();
    if (appPersistent != null) {
        appPersistent.setOrderNumber(orderNumber);
        appPersistent.save();
    } else {
        AppPersistent newAppPersistent = new AppPersistent(packageName, name, DEFAULT_OPEN_COUNT, DEFAULT_ORDER_NUMBER, DEFAULT_APP_VISIBILITY);
        newAppPersistent.save();
    }
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static boolean getAppVisibility(String packageName, String name) {
    String identifier = AppPersistent.generateIdentifier(packageName, name);
    AppPersistent appPersistent = Select.from(AppPersistent.class).where(Condition.prop(NamingHelper.toSQLNameDefault("mIdentifier")).eq(identifier)).first();
    if (appPersistent != null) {
        return appPersistent.isAppVisible();
    } else {
        return true;
    }
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static void setAppVisibility(String packageName, String name, boolean mHideApp) {
    String identifier = AppPersistent.generateIdentifier(packageName, name);
    AppPersistent appPersistent = Select.from(AppPersistent.class).where(Condition.prop(NamingHelper.toSQLNameDefault("mIdentifier")).eq(identifier)).first();
    if (appPersistent != null) {
        appPersistent.setAppVisible(mHideApp);
        appPersistent.save();
    } else {
        AppPersistent newAppPersistent = new AppPersistent(packageName, name, DEFAULT_OPEN_COUNT, DEFAULT_ORDER_NUMBER, mHideApp);
        newAppPersistent.save();
    }
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static long getAppOpenCount(String packageName, String name) {
    String identifier = AppPersistent.generateIdentifier(packageName, name);
    AppPersistent appPersistent = Select.from(AppPersistent.class).where(Condition.prop(NamingHelper.toSQLNameDefault("mIdentifier")).eq(identifier)).first();
    if (appPersistent != null) {
        return appPersistent.getOpenCount();
    } else {
        return 0;
    }
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static boolean exists(@NonNull String activityInfoName, @NonNull String packageName) {
    return Select.from(AppsModel.class)
            .where(Condition.prop(NamingHelper.toSQLNameDefault("activityInfoName")).eq(activityInfoName))
            .and(Condition.prop(NamingHelper.toSQLNameDefault("packageName")).eq(packageName))
            .and(Condition.prop(NamingHelper.toSQLNameDefault("folderId")).eq(0))
            .first() != null;
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static List<String> getHours(Integer day) {
    List<String> hours = new ArrayList<>();
    List<Lesson> lessons = Select.from(Lesson.class)
            .where(Condition.prop("day").eq(day), Condition.prop("hidden").eq("0"))
            .list();

    for (Lesson lesson : lessons) {
        if (hours.indexOf(lesson.getTime()) == -1) {
            hours.add(lesson.getTime());
        }
    }

    return hours;
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static List<Lesson> getLessonsForHour(Integer day, String time) {
    return Select.from(Lesson.class)
            .where(Condition.prop("day").eq(day),
                    Condition.prop("time").eq(time),
                    Condition.prop("hidden").eq("0"))
            .list();
}
 

import com.orm.query.Condition; //导入依赖的package包/类
@Override
    public void onBindViewHolder(final ViewHolder viewHolder, final int i) {


        List<WilayahDB> wilayahDBs = Select.from(WilayahDB.class)
                .where(Condition.prop("dapil").eq(data.get(i).getId()))
                .list();
        StringBuffer buffer = new StringBuffer();
        int z = 0;
        for (WilayahDB wilayahDB : wilayahDBs) {
            buffer.append(wilayahDB.getNama());
            if (z < wilayahDBs.size() - 1) {
                buffer.append(",");
            }
            z++;
        }
        String wil = buffer.toString();
        viewHolder.nama.setText(wil);
        viewHolder.nama_lengkap.setText(data.get(i).getNama() + " (" + data.get(i).getJumlah_kursi() + " Kursi)");

        viewHolder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
//                HomeListFragment.dataDapil = data.get(i);
                Intent intent = new Intent();
//                data.get(i).setIdDapil(dapils.get(i).getId());
                intent.putExtra(Constant.TAG.DATADAPIL, data.get(i));
                activity.setResult(Activity.RESULT_OK, intent);
                activity.finish();
            }
        });

    }
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Has the article already been added to the list
 */
public static boolean isArticleInList(String articleUrl) {
    SendHeadline headline = Select.from(SendHeadline.class)
                                    .where(Condition.prop(SendHeadline.ARTICLE_URL_COL).eq(articleUrl))
                                    .first();
    return headline != null;
}
 

import com.orm.query.Condition; //导入依赖的package包/类
/**
 * Get the set of headline objects that have been saved from the wearable
 */
public static List<SendHeadline> getSavedHeadlines() {
    return Select.from(SendHeadline.class)
            .where(Condition.prop(SendHeadline.IN_READ_LIST_COL).eq(1))
            .orderBy(SendHeadline.HEADLINE_COL)
            .list();
}
 

import com.orm.query.Condition; //导入依赖的package包/类
public static boolean doesUserExist(String username, String pwd) {
    User user = Select.from(User.class)
            .where(Condition.prop(StringUtil.toSQLName("username")).eq(username))
            .where(Condition.prop(StringUtil.toSQLName("password")).eq(pwd))
            .first();
    if (user != null)
        return true;
    return false;
}