add project adins

MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/f0/f00d5a787c447b399e26032726b079307fa4acc4.svn-base

@@ -0,0 +1,55 @@
+package com.adins.mss.base.timeline.comment;
+
+import android.content.Context;
+
+import com.adins.mss.dao.Comment;
+import com.adins.mss.foundation.db.dataaccess.CommentDataAccess;
+import com.adins.mss.foundation.formatter.Tool;
+
+import java.util.Date;
+import java.util.List;
+
+public class CommentManager {
+    private Context mContext;
+
+    public CommentManager(Context context) {
+        this.mContext = context;
+    }
+
+    public List<Comment> getAllComment(String uuid_timeline) {
+        return CommentDataAccess.getAll(mContext, uuid_timeline);
+    }
+
+    public void insertComment(List<Comment> commentList) {
+        CommentDataAccess.add(mContext, commentList);
+    }
+
+    public void insertComment(Comment comment) {
+        CommentDataAccess.add(mContext, comment);
+    }
+
+    public void insertComment(String content_comment, String sender_id, String sender_name, String usr_crt, String usr_upd, String uuid_timeline) {
+        String uuid_comment = Tool.getUUID();
+        Date dtm_crt_server = null;
+        Date dtm_crt = new Date(System.currentTimeMillis());
+        java.util.Date dtm_upd = new Date(System.currentTimeMillis());
+        Comment comment = new Comment(uuid_comment, content_comment, dtm_crt_server, sender_id, sender_name, usr_crt, dtm_crt, usr_upd, dtm_upd, uuid_timeline);
+        CommentDataAccess.add(mContext, comment);
+    }
+
+    public void deleteComment(Comment comment) {
+        CommentDataAccess.delete(mContext, comment);
+    }
+
+    public void deleteComment(String uuid_timeline) {
+        CommentDataAccess.delete(mContext, uuid_timeline);
+    }
+
+    public void deleteAllComment() {
+        CommentDataAccess.clean(mContext);
+    }
+
+    public void updateComment(Comment comment) {
+        CommentDataAccess.update(mContext, comment);
+    }
+}

MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/f0/f02594b6d7e23f1b8eae0e8327a46fec90c1f67a.svn-base

@@ -0,0 +1,340 @@
+package com.github.jjobes.slidedatetimepicker;
+
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//package com.example.android.common.view;
+
+import android.content.Context;
+import android.graphics.Typeface;
+import android.os.Build;
+import androidx.viewpager.widget.PagerAdapter;
+import androidx.viewpager.widget.ViewPager;
+import android.util.AttributeSet;
+import android.util.SparseArray;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.HorizontalScrollView;
+import android.widget.TextView;
+
+/**
+ * To be used with ViewPager to provide a tab indicator component which give constant feedback as to
+ * the user's scroll progress.
+ * <p>
+ * To use the component, simply add it to your view hierarchy. Then in your
+ * {@link android.app.Activity} or {@link androidx.fragment.app.Fragment} call
+ * {@link #setViewPager(ViewPager)} providing it the ViewPager this layout is being used for.
+ * <p>
+ * The colors can be customized in two ways. The first and simplest is to provide an array of colors
+ * via {@link #setSelectedIndicatorColors(int...)} and {@link #setDividerColors(int...)}. The
+ * alternative is via the {@link TabColorizer} interface which provides you complete control over
+ * which color is used for any individual position.
+ * <p>
+ * The views used as tabs can be customized by calling {@link #setCustomTabView(int, int)},
+ * providing the layout ID of your custom layout.
+ * <p>
+ * Modifed by jjobes - Added mTabTitleViews SparseArray and setTabText().
+ * Also modifed populateTabStrip() to fill mTabTitleViews.
+ */
+public class SlidingTabLayout extends HorizontalScrollView {
+
+    private static final int TITLE_OFFSET_DIPS = 24;
+    private static final int TAB_VIEW_PADDING_DIPS = 16;
+    private static final int TAB_VIEW_TEXT_SIZE_SP = 12;
+    private final SlidingTabStrip mTabStrip;
+    private int mTitleOffset;
+
+    private int mTabViewLayoutId;
+    private int mTabViewTextViewId;
+
+    // A map of the TextViews in each tab.
+    // Maps page index -> tab TextView
+    private SparseArray<TextView> mTabTitleViews = new SparseArray<TextView>();
+
+    private ViewPager mViewPager;
+    private ViewPager.OnPageChangeListener mViewPagerPageChangeListener;
+
+    public SlidingTabLayout(Context context) {
+        this(context, null);
+    }
+
+    public SlidingTabLayout(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public SlidingTabLayout(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+
+        // Disable the Scroll Bar
+        setHorizontalScrollBarEnabled(false);
+        // Make sure that the Tab Strips fills this View
+        setFillViewport(true);
+
+        mTitleOffset = (int) (TITLE_OFFSET_DIPS * getResources().getDisplayMetrics().density);
+
+        mTabStrip = new SlidingTabStrip(context);
+        addView(mTabStrip, LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+    }
+
+    /**
+     * Set the custom {@link TabColorizer} to be used.
+     * <p>
+     * If you only require simple custmisation then you can use
+     * {@link #setSelectedIndicatorColors(int...)} and {@link #setDividerColors(int...)} to achieve
+     * similar effects.
+     */
+    public void setCustomTabColorizer(TabColorizer tabColorizer) {
+        mTabStrip.setCustomTabColorizer(tabColorizer);
+    }
+
+    /**
+     * Sets the colors to be used for indicating the selected tab. These colors are treated as a
+     * circular array. Providing one color will mean that all tabs are indicated with the same color.
+     */
+    public void setSelectedIndicatorColors(int... colors) {
+        mTabStrip.setSelectedIndicatorColors(colors);
+    }
+
+    /**
+     * Sets the colors to be used for tab dividers. These colors are treated as a circular array.
+     * Providing one color will mean that all tabs are indicated with the same color.
+     */
+    public void setDividerColors(int... colors) {
+        mTabStrip.setDividerColors(colors);
+    }
+
+    /**
+     * Set the {@link ViewPager.OnPageChangeListener}. When using {@link SlidingTabLayout} you are
+     * required to set any {@link ViewPager.OnPageChangeListener} through this method. This is so
+     * that the layout can update it's scroll position correctly.
+     *
+     * @see ViewPager#setOnPageChangeListener(ViewPager.OnPageChangeListener)
+     */
+    public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
+        mViewPagerPageChangeListener = listener;
+    }
+
+    /**
+     * Set the custom layout to be inflated for the tab views.
+     *
+     * @param layoutResId Layout id to be inflated
+     * @param textViewId  id of the {@link TextView} in the inflated view
+     */
+    public void setCustomTabView(int layoutResId, int textViewId) {
+        mTabViewLayoutId = layoutResId;
+        mTabViewTextViewId = textViewId;
+    }
+
+    /**
+     * Sets the associated view pager. Note that the assumption here is that the pager content
+     * (number of tabs and tab titles) does not change after this call has been made.
+     */
+    public void setViewPager(ViewPager viewPager) {
+        mTabStrip.removeAllViews();
+
+        mViewPager = viewPager;
+        if (viewPager != null) {
+            viewPager.addOnPageChangeListener(new InternalViewPagerListener());
+            populateTabStrip();
+        }
+    }
+
+    /**
+     * Create a default view to be used for tabs. This is called if a custom tab view is not set via
+     * {@link #setCustomTabView(int, int)}.
+     */
+    protected TextView createDefaultTabView(Context context) {
+        TextView textView = new TextView(context);
+        textView.setGravity(Gravity.CENTER);
+        textView.setTextSize(TypedValue.COMPLEX_UNIT_SP, TAB_VIEW_TEXT_SIZE_SP);
+        textView.setTypeface(Typeface.DEFAULT_BOLD);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            // If we're running on Honeycomb or newer, then we can use the Theme's
+            // selectableItemBackground to ensure that the View has a pressed state
+            TypedValue outValue = new TypedValue();
+            getContext().getTheme().resolveAttribute(android.R.attr.selectableItemBackground,
+                    outValue, true);
+            textView.setBackgroundResource(outValue.resourceId);
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            // If we're running on ICS or newer, enable all-caps to match the Action Bar tab style
+            textView.setAllCaps(true);
+        }
+
+        int padding = (int) (TAB_VIEW_PADDING_DIPS * getResources().getDisplayMetrics().density);
+        textView.setPadding(padding, padding, padding, padding);
+
+        return textView;
+    }
+
+    private void populateTabStrip() {
+        final PagerAdapter adapter = mViewPager.getAdapter();
+        final OnClickListener tabClickListener = new TabClickListener();
+
+        for (int i = 0; i < adapter.getCount(); i++) {
+            View tabView = null;
+            TextView tabTitleView = null;
+
+            if (mTabViewLayoutId != 0) {
+                // If there is a custom tab view layout id set, try and inflate it
+                tabView = LayoutInflater.from(getContext()).inflate(mTabViewLayoutId, mTabStrip,
+                        false);
+                tabTitleView = (TextView) tabView.findViewById(mTabViewTextViewId);
+            }
+
+            if (tabView == null) {
+                tabView = createDefaultTabView(getContext());
+            }
+
+            if (tabTitleView == null && TextView.class.isInstance(tabView)) {
+                tabTitleView = (TextView) tabView;
+            }
+
+            tabTitleView.setText(adapter.getPageTitle(i));
+            tabView.setOnClickListener(tabClickListener);
+
+            // Used to get a reference to each tab's TextView in order to
+            // update the text in setTabText().
+            mTabTitleViews.put(i, tabTitleView);
+
+            mTabStrip.addView(tabView);
+        }
+    }
+
+    /**
+     * Set the text on the specified tab's TextView.
+     *
+     * @param index the index of the tab whose TextView you want to update
+     * @param text  the text to display on the specified tab's TextView
+     */
+    public void setTabText(int index, String text) {
+        TextView tv = mTabTitleViews.get(index);
+
+        if (tv != null) {
+            tv.setText(text);
+        }
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+
+        if (mViewPager != null) {
+            scrollToTab(mViewPager.getCurrentItem(), 0);
+        }
+    }
+
+    private void scrollToTab(int tabIndex, int positionOffset) {
+        final int tabStripChildCount = mTabStrip.getChildCount();
+        if (tabStripChildCount == 0 || tabIndex < 0 || tabIndex >= tabStripChildCount) {
+            return;
+        }
+
+        View selectedChild = mTabStrip.getChildAt(tabIndex);
+        if (selectedChild != null) {
+            int targetScrollX = selectedChild.getLeft() + positionOffset;
+
+            if (tabIndex > 0 || positionOffset > 0) {
+                // If we're not at the first child and are mid-scroll, make sure we obey the offset
+                targetScrollX -= mTitleOffset;
+            }
+
+            scrollTo(targetScrollX, 0);
+        }
+    }
+
+    /**
+     * Allows complete control over the colors drawn in the tab layout. Set with
+     * {@link #setCustomTabColorizer(TabColorizer)}.
+     */
+    public interface TabColorizer {
+
+        /**
+         * @return return the color of the indicator used when {@code position} is selected.
+         */
+        int getIndicatorColor(int position);
+
+        /**
+         * @return return the color of the divider drawn to the right of {@code position}.
+         */
+        int getDividerColor(int position);
+
+    }
+
+    private class InternalViewPagerListener implements ViewPager.OnPageChangeListener {
+        private int mScrollState;
+
+        @Override
+        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
+            int tabStripChildCount = mTabStrip.getChildCount();
+            if ((tabStripChildCount == 0) || (position < 0) || (position >= tabStripChildCount)) {
+                return;
+            }
+
+            mTabStrip.onViewPagerPageChanged(position, positionOffset);
+
+            View selectedTitle = mTabStrip.getChildAt(position);
+            int extraOffset = (selectedTitle != null)
+                    ? (int) (positionOffset * selectedTitle.getWidth())
+                    : 0;
+            scrollToTab(position, extraOffset);
+
+            if (mViewPagerPageChangeListener != null) {
+                mViewPagerPageChangeListener.onPageScrolled(position, positionOffset,
+                        positionOffsetPixels);
+            }
+        }
+
+        @Override
+        public void onPageScrollStateChanged(int state) {
+            mScrollState = state;
+
+            if (mViewPagerPageChangeListener != null) {
+                mViewPagerPageChangeListener.onPageScrollStateChanged(state);
+            }
+        }
+
+        @Override
+        public void onPageSelected(int position) {
+            if (mScrollState == ViewPager.SCROLL_STATE_IDLE) {
+                mTabStrip.onViewPagerPageChanged(position, 0f);
+                scrollToTab(position, 0);
+            }
+
+            if (mViewPagerPageChangeListener != null) {
+                mViewPagerPageChangeListener.onPageSelected(position);
+            }
+        }
+
+    }
+
+    private class TabClickListener implements OnClickListener {
+        @Override
+        public void onClick(View v) {
+            for (int i = 0; i < mTabStrip.getChildCount(); i++) {
+                if (v == mTabStrip.getChildAt(i)) {
+                    mViewPager.setCurrentItem(i);
+                    return;
+                }
+            }
+        }
+    }
+
+}

MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/f0/f02e6c6c604637304826388c5ce657934f3d225d.svn-base

@@ -0,0 +1,43 @@
+package com.adins.mss.coll.models;
+
+import java.util.List;
+
+import com.adins.mss.coll.R;
+import com.adins.mss.dao.DepositReportH;
+import com.androidquery.AQuery;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+
+public class DepositReportAdapter extends ArrayAdapter<DepositReportH> {
+	private List<DepositReportH> objects;
+	private Context context;
+	AQuery query;
+
+	public DepositReportAdapter(Context context, List<DepositReportH> objects) {
+		super(context, R.layout.new_recapitulation_item, objects);
+		this.context = context;
+		this.objects = objects;
+	}
+
+	@Override
+	public int getCount() {
+		return objects.size();
+	}
+
+	@Override
+	public View getView(final int position, View convertView, ViewGroup parent) {
+		if (convertView == null) {
+			convertView = LayoutInflater.from(getContext()).inflate(
+					R.layout.new_recapitulation_item, parent, false);
+		}
+		query = new AQuery(convertView);
+		DepositReportH reportH = objects.get(position);
+
+		query.id(R.id.txtTaskTitle).text(reportH.getBatch_id());
+		return convertView;
+	}
+}

MSS/BaseProject/Android/branches/BAFMCS_V3/.svn/pristine/f0/f0b216c0b3984f3973e171b4ee5a17ad1643a9e7.svn-base

@@ -0,0 +1,20 @@
+package com.adins.mss.foundation.sync.api;
+
+import com.adins.mss.dao.User;
+import com.adins.mss.foundation.http.MssResponseType;
+import com.google.gson.annotations.SerializedName;
+
+import java.util.List;
+
+public class SynchronizeResponseCOH extends MssResponseType {
+    @SerializedName("listSync")
+    private List<User> listSync;
+
+    public List<User> getListSync() {
+        return listSync;
+    }
+
+    public void setListSync(List<User> listSync) {
+        this.listSync = listSync;
+    }
+}