unsure

app/__init__.py

@@ -171,8 +171,6 @@ app.register_blueprint(main_blueprint, url_prefix='/main')
 from .customer import customer as customer_blueprint
 app.register_blueprint(customer_blueprint, url_prefix='/customer')
 
-from .service import service as service_blueprint
-app.register_blueprint(service_blueprint, url_prefix='/service')
 
 from .delivery import delivery as delivery_blueprint
 app.register_blueprint(delivery_blueprint, url_prefix='/delivery')

app/admin/views.py

@@ -3,9 +3,8 @@ from flask_login import current_user, logout_user, login_user, login_required
 from app.admin import admin
 from app import db
 from datetime import datetime
-from app.classes.pricing import (Pricing_Service_General,
+from app.classes.pricing import (
                                  Pricing_Oil_Oil,
-                                 Pricing_Service_General_schema,
                                  Pricing_Oil_Oil_schema)
 
 

app/auth/views.py

@@ -12,13 +12,14 @@ def check_session():
     """
     Checks auth token to ensure user is authenticated
     """
-  
+
     api_key = request.headers.get('Authorization')
     if not api_key:
         return jsonify({"error": "True"}), 200
     else:
         api_key = api_key.replace('bearer ', '', 1)
         api_key = api_key.replace('"', '')
+        
         user_exists = (db.session
                           .query(Auth_User)
                           .filter(Auth_User.api_key == api_key)
@@ -30,6 +31,7 @@ def check_session():
                 .query(Auth_User)\
                 .filter(Auth_User.api_key == api_key)\
                 .first()
+              
             return jsonify({
                 "ok": True,
                 'user': {

app/classes/delivery.py

@@ -72,28 +72,6 @@ class Delivery_Delivery_schema(ma.SQLAlchemyAutoSchema):
         model = Delivery_Delivery
 
 
-class Delivery_Payment(db.Model):
-    __tablename__ = 'delivery_payment'
-    __bind_key__ = 'eamco'
-    __table_args__ = {"schema": "public"}
-
-    id = db.Column(db.Integer,
-                   primary_key=True,
-                   autoincrement=True,
-                   unique=False)
-
-    delivery_id = db.Column(db.INTEGER)
-    time_added = db.Column(db.TIMESTAMP(), default=datetime.utcnow())
-    total_amount_oil = db.Column(db.DECIMAL(50, 2))
-    total_amount_emergency = db.Column(db.DECIMAL(50, 2))
-    total_amount_prime = db.Column(db.DECIMAL(50, 2))
-    total_amount_fee = db.Column(db.DECIMAL(50, 2))
-    total_amount = db.Column(db.DECIMAL(50, 2))
-
-class Delivery_Payment_schema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Delivery_Payment
-
 
 class Delivery_Notes_Driver(db.Model):
     __tablename__ = 'delivery_notes'

app/classes/money.py

@@ -0,0 +1,48 @@
+from app import db, ma
+from datetime import datetime, timezone
+
+
+class Money_delivery(db.Model):
+    __tablename__ = 'money_delivery'
+    __bind_key__ = 'eamco'
+    __table_args__ = {"schema": "public"}
+
+    id = db.Column(db.Integer,
+                   primary_key=True,
+                   autoincrement=True,
+                   unique=False)
+
+    delivery_id = db.Column(db.INTEGER)
+    time_added = db.Column(db.TIMESTAMP(), datetime.now(timezone.utc).replace(tzinfo=None))
+    gallons_delivered = db.Column(db.DECIMAL(50, 2))
+    supplier_price = db.Column(db.DECIMAL(50, 2))
+    customer_price = db.Column(db.DECIMAL(50, 2))
+    
+    total_amount_oil = db.Column(db.DECIMAL(50, 2))
+    total_amount_prime = db.Column(db.DECIMAL(50, 2))
+    total_amount_same_day = db.Column(db.DECIMAL(50, 2))
+    total_amount_fee = db.Column(db.DECIMAL(50, 2))
+    total_amount = db.Column(db.DECIMAL(50, 2))
+
+    taxes_paid = db.Column(db.DECIMAL(50, 2))
+    total_profit = db.Column(db.DECIMAL(50, 2))
+    
+    
+class Money_delivery_schema(ma.SQLAlchemyAutoSchema):
+    class Meta:
+        model = Money_delivery
+
+
+
+class Pricing_Taxes(db.Model):
+    __tablename__ = 'pricing_taxes'
+    __bind_key__ = 'eamco'
+    __table_args__ = {"schema": "public"}
+
+    id = db.Column(dn.Integer,
+                   primary_key=True,
+                   autoincrement=True,
+                   unique=False)
+    state_id = db.Column(db.Integer)
+    taxes_oil = db.Column(db.DECIMAL(50, 2))
+    taxes_other = db.Column(db.DECIMAL(50, 2))

app/classes/pricing.py

@@ -2,28 +2,7 @@ from app import db, ma, login_manager
 from datetime import datetime
 
 
-class Pricing_Service_General(db.Model):
-    __tablename__ = 'pricing_service_general'
-    __bind_key__ = 'eamco'
-    __table_args__ = {"schema": "public"}
 
-    id = db.Column(db.Integer,
-                   primary_key=True,
-                   autoincrement=True,
-                   unique=False)
-
-    price_service_hour = db.Column(db.DECIMAL(50, 2))
-    price_emergency_service_hour = db.Column(db.DECIMAL(50, 2))
-    price_emergency_call = db.Column(db.DECIMAL(50, 2))
-    price_out_of_oil = db.Column(db.DECIMAL(50, 2))
-    price_prime = db.Column(db.DECIMAL(50, 2))
-    price_cleaning = db.Column(db.DECIMAL(50, 2))
-    date = db.Column(db.TIMESTAMP(), default=datetime.utcnow())
-
-
-class Pricing_Service_General_schema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Pricing_Service_General
 
 
 class Pricing_Oil_Oil(db.Model):

app/classes/service.py

@@ -1,126 +0,0 @@
-
-from app import db, ma
-from datetime import datetime
-
-
-class Service_Call(db.Model):
-    __tablename__ = 'service_call'
-    __bind_key__ = 'eamco'
-    __table_args__ = {"schema": "public"}
-    
-    id = db.Column(db.Integer,
-                   primary_key=True,
-                   autoincrement=True,
-                   unique=False)
-    
-    customer_id = db.Column(db.INTEGER)
-    customer_last_name = db.Column(db.VARCHAR(250))
-    customer_first_name = db.Column(db.VARCHAR(250))
-    customer_town = db.Column(db.VARCHAR(140))
-    customer_state = db.Column(db.INTEGER)
-    customer_zip = db.Column(db.VARCHAR(25))
-    customer_apt = db.Column(db.VARCHAR(140))
-    customer_address = db.Column(db.VARCHAR(1000))
-
-    #0 = closed
-    #1 = open
-    status = db.Column(db.INTEGER)
-
-    # 0 = unknown
-    # 1 = cleaning / tuneup
-    # 2 = problem
-    # 3 = install
-    # 3 = callback
-    service_type = db.Column(db.INTEGER)
-    # when the call to service took place
-    when_called = db.Column(db.DATE(), default=datetime.utcnow())
-    # what day the call will take place
-    scheduled_date = db.Column(db.DATE(), default=datetime.utcnow())
-    # what day the call will take place
-    scheduled_time = db.Column(db.INTEGER)
-    # when the service took place
-    when_serviced = db.Column(db.DATE(), default=datetime.utcnow())
-    # is the call finished or not
-    # 0  = open
-    #1 = finished
-    completed = db.Column(db.INTEGER)
-    tech_id = db.Column(db.INTEGER)
-    tech_first_name = db.Column(db.VARCHAR(300))
-    tech_last_name = db.Column(db.VARCHAR(300))
-
-    payment_type = db.Column(db.INTEGER)
-    payment_card_id = db.Column(db.INTEGER)
-
-
-class Service_Call_schema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Service_Call
-
-
-class Service_Call_Money(db.Model):
-    __tablename__ = 'service_money'
-    __bind_key__ = 'eamco'
-    __table_args__ = {"schema": "public"}
-    
-    id = db.Column(db.Integer,
-                   primary_key=True,
-                   autoincrement=True,
-                   unique=False)
-    
-    service_call_id = db.Column(db.INTEGER)
-    hours = db.Column(db.DECIMAL(50, 2))
-    cost_per_hour = db.Column(db.DECIMAL(50, 2))
-    parts_cost = db.Column(db.DECIMAL(50, 2))
-
-
-class Service_Call_Money_schema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Service_Call_Money
-
-
-class Service_Call_Notes_Dispatcher(db.Model):
-    __tablename__ = 'service_notes_dispatcher'
-    __bind_key__ = 'eamco'
-    __table_args__ = {"schema": "public"}
-    
-    id = db.Column(db.Integer,
-                   primary_key=True,
-                   autoincrement=True,
-                   unique=False)
-    
-    service_call_id = db.Column(db.INTEGER)
-    dispatcher_notes = db.Column(db.TEXT)
-    dispatcher_subject = db.Column(db.VARCHAR(1024))
-    time_added = db.Column(db.TIMESTAMP(), default=datetime.utcnow())
-    dispatcher_id = db.Column(db.INTEGER)
-    dispatcher_name = db.Column(db.VARCHAR(140))
-    
-    
-class Service_Call_Notes_Dispatcher_schema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Service_Call_Notes_Dispatcher
-
-
-class Service_Call_Notes_Technician(db.Model):
-    __tablename__ = 'service_notes_technician'
-    __bind_key__ = 'eamco'
-    __table_args__ = {"schema": "public"}
-    
-    id = db.Column(db.Integer,
-                   primary_key=True,
-                   autoincrement=True,
-                   unique=False)
-    
-    service_call_id = db.Column(db.INTEGER)
-    technician_comments = db.Column(db.TEXT)
-    time_added = db.Column(db.TIMESTAMP(), default=datetime.utcnow())
-    technician_id = db.Column(db.INTEGER)
-    technician_name = db.Column(db.VARCHAR(140))
-
-
-class Service_Call_Notes_Technician_schema(ma.SQLAlchemyAutoSchema):
-    class Meta:
-        model = Service_Call_Notes_Technician
-
-
-

app/classes/stats_employee.py

@@ -1,5 +1,5 @@
 
-from app import db, ma, login_manager
+from app import db, ma
 from datetime import datetime
 
 
@@ -12,11 +12,10 @@ class Stats_Employee_Oil(db.Model):
                    primary_key=True,
                    autoincrement=True,
                    unique=False)
-    
+    employee_id = db.Column(db.INTEGER)
     total_deliveries = db.Column(db.INTEGER)
     total_gallons_delivered = db.Column(db.INTEGER)
     total_primes = db.Column(db.INTEGER)
-    total_gallons_fuel = db.Column(db.INTEGER)
     oil_total_profit_delivered = db.Column(db.DECIMAL(50, 2))
     
 class Stats_Employee_Oil_schema(ma.SQLAlchemyAutoSchema):
@@ -26,8 +25,10 @@ class Stats_Employee_Oil_schema(ma.SQLAlchemyAutoSchema):
 
 
 
-class Stats_Employee_Service(db.Model):
+
-    __tablename__ = 'stats_employee_service'
+
+class Stats_Employee_Office(db.Model):
+    __tablename__ = 'stats_employee_office'
     __bind_key__ = 'eamco'
     __table_args__ = {"schema": "public"}
     
@@ -36,11 +37,12 @@ class Stats_Employee_Service(db.Model):
                    autoincrement=True,
                    unique=False)
     
-    total_service_calls = db.Column(db.INTEGER)
+    employee_id = db.Column(db.INTEGER)
-    total_service_calls_hours = db.Column(db.INTEGER)
+    total_orders = db.Column(db.INTEGER)
-    total_gallons_fuel = db.Column(db.INTEGER)
+    total_credit_cards_proccessed = db.Column(db.INTEGER)
-    total_amount_billed= db.Column(db.DECIMAL(50, 2))
+    
-    total_profit_made = db.Column(db.DECIMAL(50, 2))
+class Stats_Employee_Office_schema(ma.SQLAlchemyAutoSchema):
-class Stats_Employee_Service_schema(ma.SQLAlchemyAutoSchema):
     class Meta:
-        model = Stats_Employee_Service
+        model = Stats_Employee_Office
+
+

app/delivery/views.py

@@ -7,14 +7,12 @@ from app.classes.customer import Customer_Customer
 from app.classes.delivery import (Delivery_Delivery,
                                   Delivery_Delivery_schema,
                                   Delivery_Notes_Driver,
-                                  Delivery_Payment,
-                                  Delivery_Payment_schema,
                                   )
 from app.classes.employee import Employee_Employee
 from app.classes.cards import Card_Card
 from app.classes.pricing import Pricing_Oil_Oil
 from app.classes.auth import Auth_User
-from app.classes.pricing import Pricing_Service_General
+
 
 
 
@@ -61,15 +59,6 @@ def get_a_specific_delivery(delivery_id):
     return jsonify(delivery_schema.dump(get_delivery))
 
 
-@delivery.route("/order/money/<int:delivery_id>", methods=["GET"])
-def get_a_specific_delivery_money(delivery_id):
-
-    get_delivery_money = db.session\
-                .query(Delivery_Payment)\
-                .filter(Delivery_Payment.id == delivery_id)\
-                .first()
-    delivery_schema = Delivery_Payment_schema(many=False)
-    return jsonify(delivery_schema.dump(get_delivery_money))
 
 
 @delivery.route("/cash/<int:delivery_id>/<int:type_of_payment>", methods=["PUT"])
@@ -97,11 +86,11 @@ def get_deliveries_not_delivered_all():
     This will get deliveries not done
     """
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status != 1) \
+        .filter(Delivery_Delivery.delivery_status != 1) 
-        .filter(Delivery_Delivery.delivery_status != 3) \
+        .filter(Delivery_Delivery.delivery_status != 3) 
-        .all()
+        .all())
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -120,10 +109,10 @@ def get_deliveries_from_customer(customer_id, page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.customer_id == customer_id) \
+        .filter(Delivery_Delivery.customer_id == customer_id) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -142,11 +131,11 @@ def get_deliveries_not_delivered(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session\
+    deliveries = (db.session
-                        .query(Delivery_Delivery)\
+                        .query(Delivery_Delivery)
-                        .filter(Delivery_Delivery.delivery_status == 0)\
+                        .filter(Delivery_Delivery.delivery_status == 0)
-                        .order_by(Delivery_Delivery.when_ordered.desc())\
+                        .order_by(Delivery_Delivery.when_ordered.desc())
-                        .limit(per_page_amount).offset(offset_limit)
+                        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -164,11 +153,11 @@ def get_deliveries_waiting(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 0) \
+        .filter(Delivery_Delivery.delivery_status == 0) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -186,11 +175,11 @@ def get_deliveries_delivered(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 1) \
+        .filter(Delivery_Delivery.delivery_status == 1) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -208,15 +197,39 @@ def get_deliveries_outfordelivery(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 2) \
+        .filter(Delivery_Delivery.delivery_status == 2) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
 
+@delivery.route("/tommorrow/<int:page>", methods=["GET"])
+def get_deliveries_tommorrow(page):
+    """
+    This will get deliveries not done
+    """
+    tomm = date.today() + timedelta(days=1)
+    per_page_amount = 50
+    if page is None:
+        offset_limit = 0
+    elif page == 1:
+        offset_limit = 0
+    else:
+        offset_limit = (per_page_amount * page) - per_page_amount
+
+    deliveries = (db.session 
+        .query(Delivery_Delivery) 
+        .filter(Delivery_Delivery.expected_delivery_date == tomm)
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
+        .limit(per_page_amount).offset(offset_limit))
+
+    customer_schema = Delivery_Delivery_schema(many=True)
+    return jsonify(customer_schema.dump(deliveries))
+
+
 @delivery.route("/finalized/<int:page>", methods=["GET"])
 def get_deliveries_finalized(page):
     """
@@ -230,11 +243,11 @@ def get_deliveries_finalized(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 10) \
+        .filter(Delivery_Delivery.delivery_status == 10) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -254,11 +267,11 @@ def get_deliveries_cancelled(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 3) \
+        .filter(Delivery_Delivery.delivery_status == 3) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -277,11 +290,11 @@ def get_deliveries_partial(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 4) \
+        .filter(Delivery_Delivery.delivery_status == 4) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -299,11 +312,11 @@ def get_deliveries_issue(page):
     else:
         offset_limit = (per_page_amount * page) - per_page_amount
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.delivery_status == 5) \
+        .filter(Delivery_Delivery.delivery_status == 5) 
-        .order_by(Delivery_Delivery.when_ordered.desc()) \
+        .order_by(Delivery_Delivery.when_ordered.desc()) 
-        .limit(per_page_amount).offset(offset_limit)
+        .limit(per_page_amount).offset(offset_limit))
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
@@ -315,27 +328,14 @@ def get_deliveries_today():
     This will get today's deliveries
     """
 
-    deliveries = db.session \
+    deliveries = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.expected_delivery_date == date.today()) \
+        .filter(Delivery_Delivery.expected_delivery_date == date.today()) 
-        .all()
+        .all())
 
     customer_schema = Delivery_Delivery_schema(many=True)
     return jsonify(customer_schema.dump(deliveries))
 
-@delivery.route("/amount/<int:delivery_id>", methods=["GET"])
-def get_deliveries_amount_total(delivery_id):
-    """
-    This will get  deliveries totals
-    """
-
-    delivery_amount = db.session \
-        .query(Delivery_Payment) \
-        .filter(Delivery_Payment.delivery_id == delivery_id) \
-        .all()
-
-    delivery_schema = Delivery_Delivery_schema(many=False)
-    return jsonify(delivery_schema.dump(delivery_amount))
 
 
 @delivery.route("/edit/<int:delivery_id>", methods=["POST"])
@@ -348,10 +348,10 @@ def edit_a_delivery(delivery_id):
         .filter(Delivery_Delivery.id == delivery_id) \
         .first()
 
-    get_today_price = db.session \
+    get_today_price = (db.session 
-        .query(Pricing_Oil_Oil) \
+        .query(Pricing_Oil_Oil) 
-        .order_by(Pricing_Oil_Oil.id.desc()) \
+        .order_by(Pricing_Oil_Oil.id.desc()) 
-        .first()
+        .first())
 
     get_customer = db.session \
         .query(Customer_Customer) \
@@ -460,10 +460,7 @@ def create_a_delivery(user_id):
         .order_by(Pricing_Oil_Oil.id.desc())\
         .first() 
 
-    get_service_prices = (db.session
+
-                          .query(Pricing_Service_General)
-                          .order_by(Pricing_Service_General.id.desc())
-                          .first())
     if not get_customer:
         return jsonify({"ok": False}), 200
     else:
@@ -582,10 +579,9 @@ def create_a_delivery(user_id):
             pre_charge_amount=total_precharge_amount,
             total_price=precharge_amount,
             final_price=0,
-            driver_last_name = driver_l_name,
+            driver_last_name=driver_l_name,
-            driver_first_name = driver_f_name,
+            driver_first_name=driver_f_name,
-            driver_employee_id= driver_emp_id,
+            driver_employee_id=driver_emp_id,
-
         )
         
         db.session.add(new_delivery)
@@ -673,15 +669,15 @@ def delivery_note_driver(delivery_id):
     driver_notes = request.json["driver_notes"]
     now = datetime.utcnow()
     
-    user = db.session\
+    user = (db.session
-        .query(Auth_User)\
+        .query(Auth_User)
-        .filter(Auth_User.id == current_user.id)\
+        .filter(Auth_User.id == current_user.id)
-        .first()
+        .first())
         
-    get_delivery = db.session\
+    get_delivery = (db.session
-        .query(Delivery_Delivery)\
+        .query(Delivery_Delivery)
-        .filter(Delivery_Delivery.id == delivery_id)\
+        .filter(Delivery_Delivery.id == delivery_id)
-        .first()
+        .first())
         
     create_new_note = Delivery_Notes_Driver(
         delivery_id=get_delivery.id,

app/delivery_data/views.py

@@ -6,7 +6,7 @@ from app.classes.delivery import Delivery_Delivery
 from app.classes.employee import Employee_Employee
 from app.classes.cards import Card_Card
 from app.classes.pricing import Pricing_Oil_Oil
-
+from app.classes.stats_employee import Stats_Employee_Oil
 
 
 
@@ -107,21 +107,23 @@ def driver_finalize_delivery(delivery_id):
     """
     Finalizes a delivery from office
     """
-    get_delivery = db.session \
+    get_delivery = (db.session 
-        .query(Delivery_Delivery) \
+        .query(Delivery_Delivery) 
-        .filter(Delivery_Delivery.id == delivery_id) \
+        .filter(Delivery_Delivery.id == delivery_id) 
-        .first()
+        .first())
 
-    get_today_price = db.session \
+    get_today_price = (db.session 
-        .query(Pricing_Oil_Oil) \
+        .query(Pricing_Oil_Oil) 
-        .order_by(Pricing_Oil_Oil.id.desc()) \
+        .order_by(Pricing_Oil_Oil.id.desc()) 
-        .first()
+        .first())
 
+    get_stats = (db.session
+                 .query(Stats_Employee_Oil)
+                 .filter(Stats_Employee_Oil == get_delivery.driver_employee_id)
+                 .first())
 
     gallons_delivered = request.json["gallons_delivered"]
 
-    
-    
     if request.json["driver_employee_id"]:
         delivery_driver_id = request.json["delivery_driver_id"]
         get_driver = (db.session
@@ -146,11 +148,14 @@ def driver_finalize_delivery(delivery_id):
     prime_info = request.json["prime"]
     if prime_info is True:
         prime_info = 1
+        current_primes = get_stats.total_primes
+        newprimes = current_primes + 1
+        get_stats.total_primes = newprimes
     else:
         prime_info = 0
 
-
     get_delivery.gallons_delivered = gallons_delivered
+    
     get_delivery.prime = prime_info
     get_delivery.customer_filled = customer_filled
     get_delivery.cash_recieved = cash_amount
@@ -160,9 +165,24 @@ def driver_finalize_delivery(delivery_id):
         get_delivery.driver_first_name = get_driver.employee_first_name
         get_delivery.driver_employee_id = get_driver.id
         
-    # update delivery stattus to delivered
+        
-    get_delivery.delivery_status = 1
+    # update stats
+    current_deliveres = get_stats.total_deliveries + 1
+    get_stats.total_deliveries = current_deliveres
     
+    current_gallons_delivered = get_stats.total_gallons_delivered + gallons_delivered
+    get_stats.total_gallons_delivered = current_gallons_delivered
+        
+        
+        
+    # update delivery status to delivered
+    if get_delivery.payment_type == 0:
+        get_delivery.delivery_status = 10
+    else:
+        #office needs to confirm credit card
+        get_delivery.delivery_status = 1
+  
+    db.session.add(get_stats)
     db.session.add(get_delivery)
     db.session.commit()
 

app/delivery_status/views.py

@@ -47,8 +47,7 @@ def get_deliveries_driver_tommorrow(user_id):
     """
     Get deliveries for driver tommrrow
     """
-    tomm = datetime.now() + timedelta(days=1)
+    tomm = date.today() + timedelta(days=1)
-
     get_delivery = (db.session
         .query(Delivery_Delivery)
         .filter(Delivery_Delivery.driver_employee_id == user_id)
@@ -64,10 +63,13 @@ def get_deliveries_driver_waiting(user_id):
     """
     waiting deliveries scheduled out
     """
+    tomm = date.today() + timedelta(days=1)
     get_delivery = (db.session
         .query(Delivery_Delivery)
         .filter(Delivery_Delivery.driver_employee_id == user_id)
         .filter(Delivery_Delivery.delivery_status == 0)
+        .filter(Delivery_Delivery.expected_delivery_date != tomm)
+        .filter(Delivery_Delivery.expected_delivery_date != date.today())
         .all())
 
     delivery_schema = Delivery_Delivery_schema(many=True)

app/info/views.py

@@ -1,7 +1,7 @@
 from flask import jsonify
 from app.info import info
 from app import db
-from app.classes.pricing import Pricing_Oil_Oil, Pricing_Service_General
+from app.classes.pricing import Pricing_Oil_Oil
 from app.classes.admin import Admin_Company
 
 
@@ -16,21 +16,6 @@ def get_oil_price():
                     }), 200
 
 
-@info.route("/price/service", methods=["GET"])
-def get_service_price():
-    get_price_query = (db.session
-                         .query(Pricing_Service_General)
-                         .order_by(Pricing_Service_General.date.desc())
-                         .first())
-
-    return jsonify({"ok": True,
-                    'price_hourly': get_price_query.price_service_hour,
-                    'emergency_fee': get_price_query.price_emergency_call,
-                    'emergency_rate': get_price_query.price_emergency_service_hour,
-                    'prime': get_price_query.price_prime,
-                    'cleaning': get_price_query.price_cleaning,
-                    'out_of_oil': get_price_query.price_out_of_oil,
-                    }), 200
 
 
 @info.route("/company", methods=["GET"])

app/reports/views.py

@@ -8,9 +8,8 @@ from datetime import datetime
 
 from app.classes.auth import Auth_User
 from app.classes.customer import Customer_Customer
-from app.classes.service import Service_Call, Service_Call_schema
+
 from app.classes.employee import Employee_Employee
-from app.classes.service import Service_Call_Notes_Dispatcher, Service_Call_Notes_Technician
 from app.classes.delivery import Delivery_Delivery
 
 

app/search/views.py

@@ -8,9 +8,7 @@ from datetime import datetime
 
 from app.classes.auth import Auth_User
 from app.classes.customer import Customer_Customer, Customer_Customer_schema
-from app.classes.service import Service_Call, Service_Call_schema
 from app.classes.employee import Employee_Employee
-from app.classes.service import Service_Call_Notes_Dispatcher, Service_Call_Notes_Technician
 from app.classes.delivery import Delivery_Delivery, Delivery_Delivery_schema
 
 
@@ -31,7 +29,7 @@ def search_customers():
         search = search[1:]
         customer_list = (db.session
                          .query(Customer_Customer)
-                         .filter(Customer_Customer.customer_first_name.ilike(search))
+                         .filter(Customer_Customer.customer_last_name.ilike(search))
                          .all())
 
     elif search_type == '!':

app/service/__init__.py

@@ -1,7 +0,0 @@
-# coding=utf-8
-
-from flask import Blueprint
-
-service = Blueprint('service', __name__)
-
-from . import views

app/service/views.py

@@ -1,397 +0,0 @@
-from flask import request, jsonify
-from flask_login import current_user, login_required
-from app.service import service
-from app import db
-from datetime import datetime
-
-from app.classes.auth import Auth_User
-from app.classes.customer import Customer_Customer
-from app.classes.service import (Service_Call,
-                                 Service_Call_schema,
-                                 Service_Call_Notes_Dispatcher,
-                                 Service_Call_Notes_Technician,
-                                 Service_Call_Notes_Dispatcher_schema,
-                                 )
-from app.classes.cards import Card_Card
-from app.classes.employee import Employee_Employee
-
-
-@service.route("/<string:service_id>", methods=["GET"])
-@login_required
-def get_specific_service_call(service_id):
-
-    service_call = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.id == service_id) \
-        .first()
-
-    service_schema = Service_Call_schema(many=False)
-    return jsonify(service_schema.dump(service_call))
-
-
-@service.route("/paymenttype/<int:service_id>/<int:type_of_payment>", methods=["PUT"])
-def update_a_service_payment(service_id, type_of_payment):
-    """
-    This update  a delivery for example if user updates to a fill
-    """
-
-    service_call = (db.session
-        .query(Service_Call)
-        .filter(Service_Call.id == service_id)
-        .first())
-
-    service_call.payment_type = type_of_payment
-
-    db.session.add(service_call)
-    db.session.commit()
-
-    return jsonify({"ok": True}), 200
-
-
-@service.route("/call/notes/<string:service_id>", methods=["GET"])
-@login_required
-def get_service_notes_call(service_id):
-    service_call = db.session \
-        .query(Service_Call_Notes_Dispatcher) \
-        .filter(Service_Call_Notes_Dispatcher.service_call_id == service_id) \
-        .first()
-
-    service_schema = Service_Call_Notes_Dispatcher_schema(many=False)
-    return jsonify(service_schema.dump(service_call))
-
-
-@service.route("/all", methods=["GET"])
-def service_view_all():
-    """
-    Get all service calls
-    """
-
-    service_calls = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.completed == 0) \
-        .order_by(Service_Call.when_called.desc()) \
-        .all()
-
-    customer_schema = Service_Call_schema(many=True)
-    return jsonify(customer_schema.dump(service_calls))
-
-
-@service.route("/all/<int:page>", methods=["GET"])
-def service_view(page):
-    """
-    Get all service calls
-    """
-    per_page_amount = 50
-    if page is None:
-        offset_limit = 0
-    elif page == 1:
-        offset_limit = 0
-    else:
-        offset_limit = (per_page_amount * page) - per_page_amount
-
-    service_calls = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.completed == 0) \
-        .order_by(Service_Call.when_called.desc()) \
-        .limit(per_page_amount).offset(offset_limit)
-
-    customer_schema = Service_Call_schema(many=True)
-    return jsonify(customer_schema.dump(service_calls))
-
-
-@service.route("/customer/<int:customer_id>/<int:page>", methods=["GET"])
-def service_customer_view(customer_id, page):
-    """
-    Get all service calls
-    """
-    per_page_amount = 50
-    if page is None:
-        offset_limit = 0
-    elif page == 1:
-        offset_limit = 0
-    else:
-        offset_limit = (per_page_amount * page) - per_page_amount
-
-    service_calls = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.customer_id == customer_id) \
-        .order_by(Service_Call.id.desc()) \
-        .limit(per_page_amount).offset(offset_limit)
-
-    customer_schema = Service_Call_schema(many=True)
-    return jsonify(customer_schema.dump(service_calls))
-
-
-@service.route("/create/<int:user_id>", methods=["POST"])
-def service_create_call(user_id):
-    """
-    create a service call
-    """
-
-    now = datetime.utcnow()
-    get_customer = db.session \
-        .query(Customer_Customer) \
-        .filter(Customer_Customer.id == user_id) \
-        .first()
-    print(request.json)
-    get_service_type = request.json["type_of_service"]
-    service_note = request.json["dispatcher_notes_taken"]
-    service_subject = request.json["dispatcher_subject_taken"]
-    scheduled_date_date = request.json["date_scheduled"]
-    dispatcher_id = request.json["dispatcher_id"]
-
-    card_payment = request.json["credit"]
-    cash_payment = request.json["cash"]
-    try:
-        if request.json["credit_card_id"]:
-            card_payment_id = request.json["credit_card_id"]
-        else:
-            card_payment_id = None
-    except:
-        card_payment_id = None
-
-    if cash_payment is True and card_payment is False:
-        delivery_payment_method = 0
-    elif card_payment is True and cash_payment is False:
-        delivery_payment_method = 1
-
-    elif card_payment is True and cash_payment is True:
-        delivery_payment_method = 2
-    else:
-        delivery_payment_method = 3
-
-    if card_payment_id is not None:
-        get_card = (db.session
-                    .query(Card_Card)
-                    .filter(Card_Card.id == card_payment_id)
-                    .filter(Card_Card.user_id == get_customer.id)
-                    .first())
-        card_id_from_customer = get_card.id
-    else:
-        card_id_from_customer = None
-
-    date_object = datetime.strptime(scheduled_date_date, '%Y-%m-%d').date()
-
-    get_tech = (db.session
-                .query(Employee_Employee)
-                .first())
-
-    create_a_call = Service_Call(
-        customer_id=get_customer.id,
-        customer_last_name=get_customer.customer_last_name,
-        customer_first_name=get_customer.customer_first_name,
-        customer_town=get_customer.customer_town,
-        customer_state=get_customer.customer_state,
-        customer_zip=get_customer.customer_zip,
-        customer_apt=get_customer.customer_apt,
-        customer_address=get_customer.customer_address,
-        status=0,
-        service_type=get_service_type,
-        when_called=now,
-        scheduled_date=date_object,
-        when_serviced=None,
-        tech_id=get_tech.id,
-        tech_first_name=get_tech.employee_first_name,
-        tech_last_name=get_tech.employee_last_name,
-        completed=0,
-        payment_type=delivery_payment_method,
-        payment_card_id=card_id_from_customer,
-    )
-
-    db.session.add(create_a_call)
-    db.session.flush()
-
-    create_new_note = Service_Call_Notes_Dispatcher(
-        service_call_id=create_a_call.id,
-        dispatcher_subject=service_subject,
-        dispatcher_notes=service_note,
-        time_added=now,
-        dispatcher_id=dispatcher_id,
-        dispatcher_name=None,
-    )
-
-    db.session.add(create_new_note)
-    db.session.commit()
-
-    db.session.commit()
-
-    return jsonify({"ok": True,
-                    'user_id': get_customer.id,
-                    'service_id': create_a_call.id,
-                    }), 200
-
-@service.route("/delete/<int:service_id>", methods=["DELETE"])
-def service_delete_call(service_id):
-    """
-    delete a service call
-    """
-    get_call_to_delete = (db.session
-                          .query(Service_Call)
-                          .filter(Service_Call.id == service_id)
-                          .first())
-    db.session.delete(get_call_to_delete)
-    db.session.commit()
-
-    return jsonify({"ok": True}), 200
-
-
-
-@service.route("/edit/<int:service_id>", methods=["PUT"])
-def service_edit_call(service_id):
-    """
-    Update a service call
-    """
-
-    get_service_type = request.json["type_of_service"]
-    scheduled_date_date = request.json["date_scheduled"]
-    dispatcher_subject_taken = request.json["dispatcher_subject_taken"]
-    dispatcher_notes_taken = request.json["dispatcher_notes_taken"]
-    tech_id = request.json["tech_id"]
-
-    card_payment = request.json["credit"]
-    cash_payment = request.json["cash"]
-
-    if request.json["credit_card_id"]:
-        card_payment_id = request.json["credit_card_id"]
-    else:
-        card_payment_id = None
-
-    get_tech = db.session \
-        .query(Employee_Employee) \
-        .filter(Employee_Employee.id == tech_id) \
-        .first()
-
-    get_service_call_call = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.id == service_id) \
-        .first()
-
-    if card_payment_id is not None:
-        get_customer = db.session \
-            .query(Customer_Customer) \
-            .filter(Customer_Customer.id == get_service_call_call.customer_id) \
-            .first()
-
-        get_card = (db.session
-                    .query(Card_Card)
-                    .filter(Card_Card.id == card_payment_id)
-                    .filter(Card_Card.user_id == get_customer.id)
-                    .first())
-        card_id_from_customer = get_card.id
-    else:
-        card_id_from_customer = None
-
-    if cash_payment is True and card_payment is False:
-        delivery_payment_method = 0
-    elif card_payment is True and cash_payment is False:
-        delivery_payment_method = 1
-
-    elif card_payment is True and cash_payment is True:
-        delivery_payment_method = 2
-    else:
-        delivery_payment_method = 3
-
-    get_service_call_notes = (db.session
-                              .query(Service_Call_Notes_Dispatcher)
-                              .filter(Service_Call_Notes_Dispatcher.service_call_id == get_service_call_call.id)
-                              .first())
-
-    get_service_call_notes.dispatcher_subject = dispatcher_subject_taken
-    get_service_call_notes.dispatcher_notes = dispatcher_notes_taken
-
-    get_service_call_call.service_type = get_service_type
-    get_service_call_call.scheduled_date = scheduled_date_date
-    get_service_call_call.tech_id = get_tech.id
-    get_service_call_call.payment_type = delivery_payment_method
-    get_service_call_call.payment_card_id = card_id_from_customer
-
-    db.session.add(get_service_call_call)
-    db.session.commit()
-
-    return jsonify({"ok": True}), 200
-
-
-@service.route("/update/type/<int:service_id>", methods=["PUT"])
-def service_update_service_type(service_id):
-    """
-    Update a service call diagnosis
-    """
-    get_service_type = request.json["service_type"]
-
-    get_service_call = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.service_id == service_id) \
-        .first()
-
-    get_service_call.service_type = get_service_type
-
-    db.session.add(get_service_call)
-    db.session.commit()
-
-    return jsonify({"ok": True}), 200
-
-
-@service.route("/note/dispatcher/<int:service_id>", methods=["PUT"])
-def service_create_note_dispatcher(service_id):
-    """
-    Initial dispatcher note about the call
-    """
-
-    service_note = request.json["dispatcher_text"]
-    now = datetime.utcnow()
-
-    user = db.session \
-        .query(Auth_User) \
-        .filter(Auth_User.id == current_user.id) \
-        .first()
-
-    get_service_call_order = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.service_id == service_id) \
-        .first()
-
-    create_new_note = Service_Call_Notes_Dispatcher(
-        service_call_id=get_service_call_order.id,
-        dispatcher_notes=service_note,
-        time_added=now,
-        dispatcher_id=user.id,
-        dispatcher_name=user.username,
-    )
-
-    db.session.add(create_new_note)
-    db.session.commit()
-
-    return jsonify({"ok": True}), 200
-
-
-@service.route("/note/technician/<int:service_id>", methods=["PUT"])
-def service_create_note_technician(service_id):
-    """
-    Technician can create notes on the call
-    """
-
-    service_technician_notes = request.json["technician_comments"]
-    now = datetime.utcnow()
-
-    user = db.session \
-        .query(Auth_User) \
-        .filter(Auth_User.id == current_user.id) \
-        .first()
-
-    get_service_call = db.session \
-        .query(Service_Call) \
-        .filter(Service_Call.service_id == service_id) \
-        .first()
-
-    create_new_note = Service_Call_Notes_Technician(
-        service_call_id=get_service_call.id,
-        technician_comments=service_technician_notes,
-        time_added=now,
-        technician_id=user.id,
-        technician_name=user.username,
-    )
-
-    db.session.add(create_new_note)
-    db.session.commit()
-
-    return jsonify({"ok": True}), 200

app/stats/views.py

@@ -4,28 +4,33 @@ from datetime import date
 from app.stats import stats
 from app import db
 from app.classes.delivery import Delivery_Delivery
-from app.classes.service import Service_Call
 
 
-@stats.route("/delivery/count/today", methods=["GET"])
+@stats.route("/gallons/total/<int:driver_id>", methods=["GET"])
-def get_delivery_today():
+def total_gallons_delivered_driver(driver_id):
-    today_deliveries = (db.session
+    gallons_list = []
+    
+    total_gallons = db.session\
+                    .query(Delivery_Delivery)\
+                    .filter(Delivery_Delivery.driver_employee_id ==  driver_id)\
+                    .all()
+                      
+    for f in total_gallons:
+        gallons_list.append(f.gallons_delivered)
+    sum_of_gallons = (sum(gallons_list))
+  
+    return jsonify({"ok": True,
+                    'data': sum_of_gallons,
+                    }), 200
+
+@stats.route("/delivery/total/<int:driver_id>", methods=["GET"])
+def total_deliveries_driver(driver_id):
+    print(driver_id)
+    total_stops = (db.session
                         .query(Delivery_Delivery)
-                        .order_by(func.date(Delivery_Delivery.expected_delivery_date) == date.today())
+                        .filter(Delivery_Delivery.driver_employee_id == driver_id)
                         .count())
-
+    print(total_stops)
     return jsonify({"ok": True,
-                    'data': today_deliveries,
+                    'data': total_stops,
-                    }), 200
-
-
-@stats.route("/service/count/today", methods=["GET"])
-def get_service_today():
-    today_calls = (db.session
-                        .query(Service_Call)
-                        .order_by(func.date(Service_Call.scheduled_date) == date.today())
-                        .count())
-
-    return jsonify({"ok": True,
-                    'data': today_calls,
                     }), 200