Beispiel #1
0
def perform_command(command):
    """
    Performs the command by name.
    Stores the result in `Storage()`.
    :param command: command name, selected by user.
    """

    command = command.lower()
    routes = get_routes()

    try:
        command_class = routes[command]
        command_inst = command_class()

        storage = Storage()
        command_inst.perform(storage.items)
    except KeyError:
        print('Bad command, try again.')
    except UserExitException as ex:
        print(ex)
        raise
Beispiel #2
0
def storage_crud():
    if request.method == 'POST':
        new_warehouse_id = request.form['warehouse_id']
        new_container_id = request.form['container_number']
        new_product_code = request.form['product_code']
        new_quantity = float(request.form['quantity'])

        try:
            product_id = get_id_by_product_code(new_product_code)
            new_storage = Storage(container_id=new_container_id,
                                  product_id=product_id,
                                  quantity=new_quantity).create()
            return redirect('/storage_crud')
        except:
            return redirect('/storage_crud')
            # return 'There was an issue adding information about storage of product. \n\nPerhaps such a product is already stored in this container or there is no product with this code.'
    else:
        warehouses = get_all_warehouses()
        res = get_product_storage_inf()
        return render_template('storage.html',
                               storages=res,
                               warehouses=warehouses)
    def show(self):
        print(self.header)
        
        storage = Storage()
        input_func = get_option_input()
            
        def get_input():
            selected_option = input_func('Enter option: ')
            if selected_option not in self.next_menus:
                raise UserInputOptionException
            return selected_option
        
        while True:
            print('Starting test...')
            self.test(storage)

            print(self.options)

            selected_option = self.input_secure_wrap(get_input)

            if selected_option == '2':
                break
Beispiel #4
0
def main():
    """
    Main method, works infinitelly until user runs `exit` command.
    Or hits `Ctrl+C` in the console.
    """

    storage = Storage()

    try:
        with open('storage.dat', 'rb') as stor:
            storage.items = pickle.load(stor)
    except IOError:
        pass

    while True:
        try:
            command = parse_user_input()
            perform_command(command)
        except UserExitException:
            break
        except KeyboardInterrupt:
            print('Shutting down, bye!')
            break
Beispiel #5
0
    def test_files(self):
        # Attempting to access a FileField from the class raises a descriptive
        # error
        self.assertRaises(AttributeError, lambda: Storage.normal)

        # An object without a file has limited functionality.
        obj1 = Storage()
        self.assertEqual(obj1.normal.name, "")
        self.assertRaises(ValueError, lambda: obj1.normal.size)

        # Saving a file enables full functionality.
        obj1.normal.save("django_test.txt", ContentFile("content"))
        self.assertEqual(obj1.normal.name, "tests/django_test.txt")
        self.assertEqual(obj1.normal.size, 7)
        self.assertEqual(obj1.normal.read(), "content")
        obj1.normal.close()

        # File objects can be assigned to FileField attributes, but shouldn't
        # get committed until the model it's attached to is saved.
        obj1.normal = SimpleUploadedFile("assignment.txt", "content")
        dirs, files = temp_storage.listdir("tests")
        self.assertEqual(dirs, [])
        self.assertEqual(sorted(files), ["default.txt", "django_test.txt"])

        obj1.save()
        dirs, files = temp_storage.listdir("tests")
        self.assertEqual(
            sorted(files), ["assignment.txt", "default.txt", "django_test.txt"]
        )

        # Files can be read in a little at a time, if necessary.
        obj1.normal.open()
        self.assertEqual(obj1.normal.read(3), "con")
        self.assertEqual(obj1.normal.read(), "tent")
        self.assertEqual(list(obj1.normal.chunks(chunk_size=2)), ["co", "nt", "en", "t"])
        obj1.normal.close()

        # Save another file with the same name.
        obj2 = Storage()
        obj2.normal.save("django_test.txt", ContentFile("more content"))
        self.assertEqual(obj2.normal.name, "tests/django_test_1.txt")
        self.assertEqual(obj2.normal.size, 12)

        # Push the objects into the cache to make sure they pickle properly
        cache.set("obj1", obj1)
        cache.set("obj2", obj2)
        self.assertEqual(cache.get("obj2").normal.name, "tests/django_test_1.txt")

        # Deleting an object does not delete the file it uses.
        obj2.delete()
        obj2.normal.save("django_test.txt", ContentFile("more content"))
        self.assertEqual(obj2.normal.name, "tests/django_test_2.txt")

        # Multiple files with the same name get _N appended to them.
        objs = [Storage() for i in range(3)]
        for o in objs:
            o.normal.save("multiple_files.txt", ContentFile("Same Content"))
        self.assertEqual(
            [o.normal.name for o in objs],
            ["tests/multiple_files.txt", "tests/multiple_files_1.txt", "tests/multiple_files_2.txt"]
        )
        for o in objs:
            o.delete()

        # Default values allow an object to access a single file.
        obj3 = Storage.objects.create()
        self.assertEqual(obj3.default.name, "tests/default.txt")
        self.assertEqual(obj3.default.read(), "default content")
        obj3.default.close()

        # But it shouldn't be deleted, even if there are no more objects using
        # it.
        obj3.delete()
        obj3 = Storage()
        self.assertEqual(obj3.default.read(), "default content")
        obj3.default.close()

        # Verify the fix for #5655, making sure the directory is only
        # determined once.
        obj4 = Storage()
        obj4.random.save("random_file", ContentFile("random content"))
        self.assertTrue(obj4.random.name.endswith("/random_file"))

        # Clean up the temporary files and dir.
        obj1.normal.delete()
        obj2.normal.delete()
        obj3.default.delete()
        obj4.random.delete()
def main():
    storage = Storage()
    storage.fill_storage()

    main_menu = MainMenu()
    main_menu.show()
Beispiel #7
0
from datetime import datetime
from helpers import get_oder_class
from models import Storage
import json

storage = Storage()
orderbook = storage.orderbook


def create_order(request):

    data_in = request.json
    keys = sorted(list(data_in.keys()))
    if keys != ['price', 'size', 'type']:
        output = {
            "error": "Missing keys",
        }
        return 400, json.dumps(output)
    _class = get_oder_class(data_in['type'])
    order = _class(data_in['price'], data_in['size'])
    orderbook.add_order(order)
    output = {"order_id": order.id}
    return 200, json.dumps(output)


def get_order(request, id):

    for o in storage.orderbook.get_all_orders():
        if o.id == id:
            order = o
            break
Beispiel #8
0
 def perform(self, objects, *args, **kwargs):
     from models import Storage
     storage = Storage()
     for i in storage.items:
         i.done = self._done_flag
Beispiel #9
0
def isoS():

    if request.method == 'POST':

        monsel, oder, peep, serv, invo, inco, cache, modata, modlink, fdata, invooder = init_storage_zero(
        )
        invojo, filesel, docref, search11, search12, search21, search31 = init_storage_blank(
        )
        leftscreen = 1
        docref = ' '
        err = ['All is well', ' ', ' ', ' ', ' ']
        ldata = None
        #today = datetime.datetime.today().strftime('%Y-%m-%d')
        today = datetime.date.today()
        invodate = datetime.date.today()
        leftsize = 10
        monvec = [
            'Month', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
            'Sep', 'Oct', 'Nov', 'Dec'
        ]
        monlvec = [
            'January', 'February', 'March', 'April', 'May', 'June', 'July',
            'August', 'September', 'October', 'November', 'December'
        ]

        match = request.values.get('Match')
        modify = request.values.get('Modify')
        vmod = request.values.get('Vmod')
        minvo = request.values.get('MakeI')
        mpack = request.values.get('MakeP')
        viewo = request.values.get('ViewO')
        viewi = request.values.get('ViewI')
        viewp = request.values.get('ViewP')
        analyze = request.values.get('Analyze')
        print = request.values.get('Print')
        addE = request.values.get('addentity')
        addS = request.values.get('addservice')
        recpay = request.values.get('RecPay')
        hispay = request.values.get('HisPay')
        monsel = request.values.get('monsel')

        returnhit = request.values.get('Return')
        deletehit = request.values.get('Delete')
        # hidden values
        update = request.values.get('Update')
        invoupdate = request.values.get('invoUpdate')
        recupdate = request.values.get('recUpdate')
        modlink = request.values.get('passmodlink')
        emailnow = request.values.get('emailnow')
        emailinvo = request.values.get('emailInvo')
        newjob = request.values.get('NewJ')
        thisjob = request.values.get('ThisJob')

        oder = request.values.get('oder')
        invo = request.values.get('invo')
        invooder = request.values.get('invooder')
        cache = request.values.get('cache')
        peep = request.values.get('peep')
        serv = request.values.get('serv')
        inco = request.values.get('inco')

        modlink = nonone(modlink)
        oder = nonone(oder)
        invo = nonone(invo)
        invooder = nonone(invooder)
        peep = nonone(peep)
        serv = nonone(serv)
        monsel = nonone(monsel)
        inco = nonone(inco)
        modal = 0

        if returnhit is not None:
            modlink = 0
            invo = 0
            invooder = 0
            inco = 0
# ____________________________________________________________________________________________________________________B.UpdateDatabases.Storage
        if update is not None and modlink == 1:
            if oder > 0:
                modata = Storage.query.get(oder)
                desc = request.values.get('desc')
                amount = request.values.get('amount')
                thiscomp = request.values.get('thiscomp')
                dstart = request.values.get('dstart')
                balfwd = request.values.get('pybal')
                modata.Description = desc
                modata.Amount = amount
                modata.Date = dstart
                modata.BalFwd = balfwd
                ldat = People.query.filter(People.Company == thiscomp).first()
                if ldat is not None:
                    acomp = ldat.Company
                    aid = ldat.id
                else:
                    acomp = None
                    aid = None
                modata.Company = acomp
                modata.Pid = aid
                modata.Label = modata.Jo + ' ' + thiscomp + ' ' + amount
                db.session.commit()
                err[3] = 'Modification to Storage JO ' + modata.Jo + ' completed.'
                modlink = 0
            if peep > 0:
                modata = People.query.get(peep)
                modata.Ptype = 'Storage'
                vals = [
                    'company', 'fname', 'mnames', 'lname', 'addr1', 'addr2',
                    'addr3', 'idtype', 'tid', 'tel', 'email', 'assoc1',
                    'assoc2', 'date1'
                ]
                a = list(range(len(vals)))
                i = 0
                for v in vals:
                    a[i] = request.values.get(v)
                    i = i + 1
                modata.Company = a[0]
                modata.First = a[1]
                modata.Middle = a[2]
                modata.Last = a[3]
                modata.Addr1 = a[4]
                modata.Addr2 = a[5]
                modata.Addr3 = a[6]
                modata.Idtype = a[7]
                modata.Idnumber = a[8]
                modata.Telephone = a[9]
                modata.Email = a[10]
                modata.Associate1 = a[11]
                modata.Associate2 = a[12]
                modata.Date1 = a[13]
                db.session.commit()
                err = [
                    ' ', ' ', 'Modification to Entity ID ' + str(modata.id) +
                    ' completed.', ' ', ' '
                ]
                modlink = 0
                # And now update the crossover to Storage in case the Company info changed:
                cross = Storage.query.filter(Storage.Pid == peep)
                for cros in cross:
                    cros.Company = a[0]
                db.session.commit()

            if serv > 0:
                modata = Services.query.get(serv)
                vals = ['service', 'price']
                a = list(range(len(vals)))
                i = 0
                for v in vals:
                    a[i] = request.values.get(v)
                    i = i + 1
                modata.Service = a[0]
                modata.Price = a[1]
                db.session.commit()
                err = [
                    ' ', ' ', 'Modification to Services Data with ID ' +
                    str(modata.id) + ' completed.', ' ', ' '
                ]
                modlink = 0

            if inco > 0:
                modata = Income.query.get(inco)
                vals = ['desc', 'recamount', 'custref', 'recdate']
                i = 0
                for v in vals:
                    a[i] = request.values.get(v)
                    i = i + 1
                modata.Description = a[0]
                modata.Amount = a[1]
                modata.Ref = a[2]
                modata.Date = a[3]
                db.session.commit()
                err = [
                    ' ', ' ', 'Modification to Income Data with ID ' +
                    str(modata.id) + ' completed.', ' ', ' '
                ]
# ____________________________________________________________________________________________________________________E.UpdateDatabases.Storage
# ____________________________________________________________________________________________________________________B.UpdateInvoice.Storage
        if invoupdate is not None and monsel != 0:
            leftsize = 8
            odata1 = Storage.query.get(invooder)
            invojo = popjo(invooder, monsel)
            ldata = Invoices.query.filter(Invoices.SubJo == invojo).all()
            invodate = request.values.get('invodate')
            total = 0
            for data in ldata:
                iqty = request.values.get('qty' + str(data.id))
                iqty = nononef(iqty)
                data.Description = request.values.get('desc' + str(data.id))
                deach = request.values.get('cost' + str(data.id))
                if deach is not None:
                    deach = "{:.2f}".format(float(deach))
                    amount = iqty * float(deach)
                else:
                    deach = "{:.2f}".format(0.00)
                    amount = 0.00
                total = total + amount
                amount = "{:.2f}".format(amount)
                data.Qty = iqty
                data.Ea = deach
                data.Amount = amount
                data.Total = 0.00
                data.Date = invodate
                db.session.commit()

            if total > 0 and ldata is not None:
                for data in ldata:
                    data.Total = "%0.2f" % total
                    db.session.commit()
                odata1.Amount = "%0.2f" % total
                db.session.commit()

            #Remove zeros from invoice in case a zero was the mod
            Invoices.query.filter(Invoices.Qty == 0).delete()
            db.session.commit()

            #Create invoice code for order
            err = [
                ' ', ' ', 'Invoice created for Storage JO: ' + invojo, ' ', ' '
            ]
            ldata = Invoices.query.filter(Invoices.SubJo == invojo).all()
# ____________________________________________________________________________________________________________________E.UpdateInvoice.Storage

        odata = Storage.query.order_by(Storage.Jo).all()
        cdata = People.query.filter(People.Ptype == 'Storage').order_by(
            People.Company).all()
        sdata = Services.query.all()

        oder, peep, serv, numchecked = numcheck(3, odata, cdata, sdata, 0, 0,
                                                ['oder', 'peep', 'serv'])

        # ____________________________________________________________________________________________________________________E.SearchFilters.Storage

        # ____________________________________________________________________________________________________________________B.EmailInvoice.Storage
        if emailinvo is not None:
            leftsize = 10
            leftscreen = 1
            modlink = 0
            modata = Storage.query.get(invooder)
            invojo = popjo(invooder, monsel)
            ldata = Invoices.query.filter(Invoices.SubJo == invojo).order_by(
                Invoices.Ea.desc()).all()
            pdata1 = People.query.filter(People.id == modata.Pid).first()
            ldat = Invoices.query.filter(Invoices.SubJo == invojo).first()
            if pdata1 is None:
                err = [
                    ' ', ' ',
                    'There is no Billing information for this selection', ' ',
                    ' '
                ]
            else:
                email = pdata1.Email
                company = pdata1.Company
            docref = ldat.Original
            if 'vinvoice' not in docref:
                err = [
                    ' ', ' ',
                    'There is no document available for this selection', ' ',
                    ' '
                ]
            else:
                if email is not None:
                    import invoice_mimemail_S
                    invoice_mimemail_S.main(invojo, docref, email, monsel,
                                            inco, company)
                    if inco == 0:
                        for data in ldata:
                            data.Status = "E"
                            db.session.commit()
                    else:
                        for data in ldata:
                            data.Status = "P"
                            db.session.commit()
            invooder = 0
            invo = 0
            inco = 0

# ____________________________________________________________________________________________________________________E.EmailInvoice.Storage
# ____________________________________________________________________________________________________________________B.Viewers.Storage
        if viewo is not None and numchecked == 1:
            err = [
                ' ', ' ', 'There is no document available for this selection',
                ' ', ' '
            ]
            if oder > 0:
                modata = Storage.query.get(oder)
                if modata.Original is not None:
                    if len(modata.Original) > 5:
                        docref = modata.Original
                        leftscreen = 0
                        leftsize = 8
                        modlink = 0
                        err = [
                            ' ', ' ', 'Viewing document ' + docref, ' ', ' '
                        ]

        if (viewo is not None or viewi is not None
                or viewp is not None) and numchecked != 1:
            err = [
                'Must check exactly one box to use this option', ' ', ' ', ' ',
                ' '
            ]

        if viewi is not None and numchecked == 1:
            err = [
                'There is no document available for this selection', ' ', ' ',
                ' ', ' '
            ]
            if monsel == 0:
                err[1] = 'Need to select the month'
            if oder > 0 and monsel > 0:
                invooder = oder
                modata = Storage.query.get(oder)
                invojo = popjo(oder, monsel)
                ldat = Invoices.query.filter(Invoices.SubJo == invojo).first()
                if ldat.Original is not None:
                    docref = ldat.Original
                    leftscreen = 0
                    leftsize = 8
                    modlink = 5
                    err = [' ', ' ', 'Viewing document ' + docref, ' ', ' ']
# ____________________________________________________________________________________________________________________E.Viewers.Storage
# ____________________________________________________________________________________________________________________B.ModifyEntries.Storage
        if (modify is not None or vmod is not None) and numchecked == 1:
            modlink = 1
            leftsize = 8

            if oder > 0:
                modata = Storage.query.get(oder)
                if vmod is not None:
                    err = [
                        ' ', ' ',
                        'There is no document available for this selection',
                        ' ', ' '
                    ]
                    if modata.Original is not None:
                        if len(modata.Original) > 5:
                            leftscreen = 0
                            docref = modata.Original
                            err = ['All is well', ' ', ' ', ' ', ' ']

            if serv > 0:
                modata = Services.query.get(serv)
                if vmod is not None:
                    err = [
                        ' ', ' ',
                        'There is no document available for this selection',
                        ' ', ' '
                    ]

            if peep > 0:
                modata = People.query.get(peep)
                if vmod is not None:
                    err = [
                        ' ', ' ',
                        'There is no document available for this selection',
                        ' ', ' '
                    ]

        if (modify is not None or vmod is not None) and numchecked != 1:
            modlink = 0
            err[0] = ' '
            err[2] = 'Must check exactly one box to use this option'
# ____________________________________________________________________________________________________________________E.ModifyEntries.Storage
# ____________________________________________________________________________________________________________________B.AddEntries.Storage

        if addS is not None and serv > 0 and numchecked == 1:
            leftsize = 8
            modlink = 2
            modata = Services.query.get(serv)

        if addS is not None and numchecked == 0:
            leftsize = 8
            modlink = 1
            #We will create a blank line and simply modify that by updating:
            input = Services(Service='New', Price=0.00)
            db.session.add(input)
            db.session.commit()
            modata = Services.query.filter(Services.Service == 'New').first()
            serv = modata.id
            err = [' ', ' ', 'Enter Data for New Service', ' ', ' ']

        if addS is not None and numchecked > 1:
            modlink = 0
            err[0] = ' '
            err[2] = 'Must check exactly one box to use this option'

        if addE is not None and peep > 0 and numchecked == 1:
            leftsize = 8
            modlink = 3
            modata = People.query.get(peep)

        if addE is not None and numchecked == 0:
            leftsize = 8
            modlink = 1
            #We will create a blank line and simply modify that by updating:
            input = People(Company='New',
                           First='',
                           Middle='',
                           Last='',
                           Addr1='',
                           Addr2='',
                           Addr3='',
                           Idtype='',
                           Idnumber='',
                           Telephone='',
                           Email='',
                           Associate1='',
                           Associate2='',
                           Date1=today,
                           Date2=None,
                           Original=None,
                           Ptype='Storage',
                           Temp1=None,
                           Temp2=None)
            db.session.add(input)
            db.session.commit()
            modata = People.query.filter((People.Company == 'New') &
                                         (People.Ptype == 'Storage')).first()
            peep = modata.id
            modata.Company = ''
            db.session.commit()
            modata = People.query.get(peep)
            err = [' ', ' ', 'Enter Data for New Company', ' ', ' ']

        if addE is not None and numchecked > 1:
            modlink = 0
            err[0] = ' '
            err[2] = 'Must check exactly one box to use this option'
# ____________________________________________________________________________________________________________________E.AddEntries.Storage
# ____________________________________________________________________________________________________________________B.ReceivePayment.Storage

        if (recpay is not None and oder > 0 and numchecked == 1
                and monsel > 0) or recupdate is not None:
            leftsize = 8
            if recpay is not None:
                invooder = oder
            odat = Storage.query.get(invooder)
            invojo = popjo(invooder, monsel)
            ldat = Invoices.query.filter(Invoices.SubJo == invojo).first()
            err = ['Have no Invoice to Receive Against', ' ', ' ', ' ', ' ']
            if ldat is not None:
                invodate = ldat.Date
                if ldat.Original is not None:
                    docref = ldat.Original
                    leftscreen = 0
                    leftsize = 8

                incdat = Income.query.filter(Income.SubJo == invojo).first()
                if incdat is None:
                    err = ['Creating New Payment on SubJo', ' ', ' ', ' ', ' ']
                    paydesc = 'Received payment on Invoice ' + invojo + ' for month of ' + monvec[
                        monsel]
                    recamount = str(ldat.Amount)
                    custref = 'ChkNo'
                    recdate = datetime.date(today.year, monsel, 28)
                    input = Income(Jo=odat.Jo,
                                   SubJo=invojo,
                                   Pid=odat.Pid,
                                   Description=paydesc,
                                   Amount=recamount,
                                   Ref=custref,
                                   Date=recdate,
                                   Original=None)
                    db.session.add(input)
                    payment = 0
                else:
                    recamount = request.values.get('recamount')
                    custref = request.values.get('custref')
                    desc = request.values.get('desc')
                    recdate = request.values.get('recdate')
                    incdat.Amount = recamount
                    incdat.Ref = custref
                    incdat.Description = desc
                    incdat.Date = recdate
                db.session.commit()
                payment = [recamount, custref, recdate]

                modata = Income.query.filter(Income.SubJo == invojo).first()
                inco = modata.id
                err = [' ', ' ', 'Amend Payment for Invoice', ' ', ' ']

                ldata = Invoices.query.filter(
                    Invoices.SubJo == invojo).order_by(
                        Invoices.Ea.desc()).all()
                pdata1 = People.query.filter(People.id == odat.Pid).first()
                cache = nonone(odat.Cache) + 1

                basejo = odat.Jo
                involine, paidline, refline, balline = money12(basejo)

                balduenow = balline[monsel]
                try:
                    balduenow = float[balduenow]
                except:
                    balduenow = 0.00
                if balduenow < .001:
                    for data in ldata:
                        data.Status = "P"
                        db.session.commit()

                import make_S_invoice
                make_S_invoice.main(odat, ldata, pdata1, invojo, involine,
                                    paidline, refline, balline, invodate,
                                    cache, payment)

                if cache > 1:
                    docref = f'tmp/{scac}/data/vinvoice/INV' + invojo + 'c' + str(
                        cache) + '.pdf'
                    # Store for future use
                else:
                    docref = f'tmp/{scac}/data/vinvoice/INV' + invojo + '.pdf'

                odat.Cache = cache
                idat = Invoices.query.filter(Invoices.SubJo == invojo).first()
                idat.Original = docref
                db.session.commit()
                leftscreen = 0
                err[4] = 'Viewing ' + docref

        if recpay is not None and (oder == 0 or numchecked != 1
                                   or monsel == 0):
            err = ['Invalid selections:', '', '', '', '']
            if oder == 0:
                err[1] = 'Must select a Storage Job'
            if numchecked != 1:
                err[2] = 'Must select exactly one Storage Job'
            if monsel == 0:
                err[3] = 'Must select a month to apply payment'
# ____________________________________________________________________________________________________________________E.ReceivePayment.Storage
# ____________________________________________________________________________________________________________________B.PaymentHistory.Storage
        if hispay is not None or modlink == 7:
            if oder == 0 and invooder == 0:
                err[1] = 'Must select a Storage Job'
            else:
                if oder != 0:
                    invooder = oder
                modata = Storage.query.get(invooder)
                ldata = Invoices.query.filter(
                    Invoices.Jo == modata.Jo).order_by(Invoices.SubJo).all()
                fdata = Income.query.filter(Income.Jo == modata.Jo).order_by(
                    Income.SubJo).all()
                #Check to see if we need to delete anything from history
                killthis = request.values.get('killthis')
                if killthis is not None and modlink == 7:
                    for data in ldata:
                        testone = request.values.get('bill' + str(data.id))
                        if testone:
                            kill = int(testone)
                            Invoices.query.filter(Invoices.id == kill).delete()
                            db.session.commit()
                    for data in fdata:
                        testone = request.values.get('pay' + str(data.id))
                        if testone:
                            kill = int(testone)
                            Income.query.filter(Income.id == kill).delete()
                            db.session.commit()
                    ldata = Invoices.query.filter(
                        Invoices.Jo == modata.Jo).order_by(
                            Invoices.SubJo).all()
                    fdata = Income.query.filter(
                        Income.Jo == modata.Jo).order_by(Income.SubJo).all()

                leftsize = 8
                modlink = 7
# ____________________________________________________________________________________________________________________E.PaymentHistory.Storage
# ____________________________________________________________________________________________________________________B.Delete.Storage
        if deletehit is not None and numchecked == 1:
            if oder > 0:
                Storage.query.filter(Storage.id == oder).delete()
                odata = Storage.query.all()
            if peep > 0:
                People.query.filter(People.id == peep).delete()
                cdata = People.query.filter(
                    People.Ptype == 'Storage').order_by(People.Company).all()
            if serv > 0:
                Services.query.filter(Services.id == serv).delete()
                sdata = Services.query.all()
            db.session.commit()
        if deletehit is not None and numchecked != 1:
            err = [
                ' ', ' ',
                'Must have exactly one item checked to use this option', ' ',
                ' '
            ]
# ____________________________________________________________________________________________________________________E.Delete.Storage
# ____________________________________________________________________________________________________________________B.Invoicing.Storage
        if ((minvo is not None and oder > 0)
                or invoupdate is not None) and monsel > 0:
            err = ['Could not create invoice', ' ', ' ', ' ', ' ']
            # First time through: have an order to invoice
            if oder > 0:
                invooder = oder
            myo = Storage.query.get(invooder)
            fee = myo.Amount
            #Check to see if we have the required data to make an invoice:
            invojo = popjo(invooder, monsel)
            thismonth = calendar.month_name[monsel]
            invodate = request.values.get('invodate')

            invo = 1
            leftsize = 8
            cache = nonone(myo.Cache) + 1
            mys = Services.query.get(serv)
            if mys is not None:
                addserv = mys.Service
                price = mys.Price
                qty = 1
                d = datetime.date(today.year, monsel, 1)
                descript = 'Monthly Storage Fee for Month of ' + thismonth
                input = Invoices(Jo=myo.Jo,
                                 SubJo=invojo,
                                 Pid=myo.Pid,
                                 Service=addserv,
                                 Description=descript,
                                 Ea=price,
                                 Qty=qty,
                                 Amount=price,
                                 Total=price,
                                 Date=d,
                                 Original=None,
                                 Status='New')
                db.session.add(input)
                db.session.commit()

            ldata = Invoices.query.filter(Invoices.SubJo == invojo).first()
            if ldata is None:
                invodate = datetime.date(today.year, monsel, 1)
                #See if there is an invoice from previous month to copy from
                try:
                    invojoprev = popjo(invooder, monsel - 1)
                    invodate = datetime.date(today.year, monsel, 1)
                    ldata2 = Invoices.query.filter(
                        Invoices.SubJo == invojoprev).all()
                    for data in ldata2:
                        mydescript = data.Description
                        newdescript = data.Description
                        for i in range(12):
                            if monlvec[i] in newdescript:
                                j = i + 1
                                if j == 12:
                                    j = 0
                                mydescript = newdescript.replace(
                                    monlvec[i], monlvec[j])

                        input = Invoices(Jo=myo.Jo,
                                         SubJo=invojo,
                                         Pid=myo.Pid,
                                         Service=data.Service,
                                         Description=mydescript,
                                         Ea=data.Ea,
                                         Qty=data.Qty,
                                         Amount=data.Amount,
                                         Date=invodate,
                                         Total=data.Total,
                                         Original=None,
                                         Status='New')
                        db.session.add(input)
                        db.session.commit()
                except:
                    if mys is None:
                        addserv = 'Monthly Storage'
                        price = fee
                    else:
                        addserv = mys.Service
                        price = mys.Price

                    qty = 1
                    invodate = datetime.date(today.year, monsel, 1)
                    descript = 'Monthly Storage Fee for Month of ' + thismonth
                    input = Invoices(Jo=myo.Jo,
                                     SubJo=invojo,
                                     Pid=myo.Pid,
                                     Service=addserv,
                                     Description=descript,
                                     Ea=price,
                                     Qty=qty,
                                     Amount=price,
                                     Date=invodate,
                                     Total=price,
                                     Original=None,
                                     Status='New')
                    db.session.add(input)
                    db.session.commit()
                else:
                    ldat = Invoices.query.filter(
                        Invoices.SubJo == invojo).first()
                    if ldat is None:
                        if mys is None:
                            addserv = 'Monthly Storage'
                            price = fee
                        else:
                            addserv = mys.Service
                            price = mys.Price

                        qty = 1
                        invodate = datetime.date(today.year, monsel, 1)
                        descript = 'Monthly Storage Fee for Month of ' + thismonth
                        input = Invoices(Jo=myo.Jo,
                                         SubJo=invojo,
                                         Pid=myo.Pid,
                                         Service=addserv,
                                         Description=descript,
                                         Ea=price,
                                         Qty=qty,
                                         Amount=price,
                                         Date=invodate,
                                         Total=price,
                                         Original=None,
                                         Status='New')
                        db.session.add(input)
                        db.session.commit()
                    ldat = Invoices.query.filter(
                        Invoices.SubJo == invojo).first()
                    invodate = ldat.Date

            # If have ldata:
            err = [' ', ' ', 'Created invoice for JO= ' + invojo, ' ', ' ']

            ldata = Invoices.query.filter(Invoices.SubJo == invojo).order_by(
                Invoices.Ea.desc()).all()
            pdata1 = People.query.filter(People.id == myo.Pid).first()

            odat = Storage.query.get(invooder)
            basejo = odat.Jo
            involine, paidline, refline, balline = money12(basejo)

            import make_S_invoice
            make_S_invoice.main(odat, ldata, pdata1, invojo, involine,
                                paidline, refline, balline, invodate, cache, 0)

            if cache > 1:
                docref = f'tmp/{scac}/data/vinvoice/INV' + invojo + 'c' + str(
                    cache) + '.pdf'
                # Store for future use
            else:
                docref = f'tmp/{scac}/data/vinvoice/INV' + invojo + '.pdf'

            odat.Path = docref
            odat.Cache = cache
            idat = Invoices.query.filter(Invoices.SubJo == invojo).first()
            idat.Original = docref
            db.session.commit()
            leftscreen = 0
            err[4] = 'Viewing ' + docref
            modata = Storage.query.get(invooder)
        elif minvo is not None and monsel == 0:
            err = [' ', ' ', 'Choose a Month for the Invoice', ' ', ' ']
        elif minvo is not None:
            err = [
                ' ', ' ', 'Must select at least 1 Job for this selection', ' ',
                ' '
            ]
# ____________________________________________________________________________________________________________________E.Invoicing.Storage

# ____________________________________________________________________________________________________________________B.NewJob.Storage
        if newjob is not None:
            err = ['Select Source Document from List']
            fdata = myoslist(f'tmp/{scac}/data/vunknown')
            modlink = 4
            leftsize = 8
            leftscreen = 0
            docref = f'tmp/{scac}/data/vunknown/NewJob.pdf'

        if newjob is None and modlink == 4:
            filesel = request.values.get('FileSel')
            if filesel != '1':
                fdata = myoslist(f'tmp/{scac}/data/vunknown')
                leftsize = 8
                leftscreen = 0
                docref = f'tmp/{scac}/data/vunknown/' + filesel

        if thisjob is not None:
            modlink = 0
            #Create the new database entry for the source document
            filesel = request.values.get('FileSel')
            if filesel != '1':
                docold = f'tmp/{scac}/data/vunknown/' + filesel
                docref = f'tmp/{scac}/data/vorders/' + filesel
                shutil.move(addpath(docold), addpath(docref))
            else:
                docref = ''
            sdate = request.values.get('dstart')
            if sdate is None:
                sdate = today

            jtype = 'S'
            nextjo = newjo(jtype, sdate)

            thisdesc = request.values.get('thisdesc')
            thisamt = request.values.get('thisamt')
            thiscomp = request.values.get('thiscomp')
            pybal = request.values.get('pybal')
            ldat = People.query.filter(People.Company == thiscomp).first()
            if ldat is not None:
                acomp = ldat.Company
                aid = ldat.id
            else:
                acomp = None
                aid = None
            label = nextjo + ' ' + thiscomp + ' ' + thisamt
            input = Storage(Jo=nextjo,
                            Description=thisdesc,
                            BalFwd=pybal,
                            Amount=thisamt,
                            Status='New',
                            Cache=1,
                            Original=docref,
                            Path=None,
                            Pid=aid,
                            Company=thiscomp,
                            Date=sdate,
                            Label=label)

            db.session.add(input)
            db.session.commit()
            modata = Storage.query.filter(Storage.Jo == nextjo).first()
            csize = People.query.filter(People.Ptype == 'Storage').order_by(
                People.Company).all()
            oder = modata.id
            leftscreen = 1
            err = ['All is well', ' ', ' ', ' ', ' ']
            odata = Storage.query.all()
# ____________________________________________________________________________________________________________________E.New Job.Storage
# ____________________________________________________________________________________________________________________B.Matching.Storage
        if match is not None:
            if oder > 0 and peep > 0 and numchecked == 2:
                myo = Storage.query.get(oder)
                myp = People.query.get(peep)
                myo.Pid = peep
                myo.Company = myp.Company
                db.session.commit()
            if numchecked != 2:
                err[1] = 'Must select exactly 2 boxes to use this option.'
                err[0] = ' '
# ____________________________________________________________________________________________________________________E.Matching.Storage

# Create the time oriented data for the columns
        bm, cm = timedata(odata)
    #This is the else for 1st time through
    else:
        # ____________________________________________________________________________________________________________________B.STORAGEnotPost

        odata = Storage.query.order_by(Storage.Jo).all()
        cdata = People.query.filter(People.Ptype == 'Storage').order_by(
            People.Company).all()
        sdata = Services.query.all()
        ldata = None
        today = datetime.datetime.today().strftime('%Y-%m-%d')
        invodate = today
        monsel, oder, peep, serv, invo, inco, cache, modata, modlink, fdata, invooder = init_storage_zero(
        )
        invojo, filesel, docref, search11, search12, search21, search31 = init_storage_blank(
        )
        monvec = [
            'All', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
            'Sep', 'Oct', 'Nov', 'Dec'
        ]
        leftscreen = 1
        leftsize = 10
        docref = ' '
        err = ['All is well', ' ', ' ', ' ', ' ']
        bm, cm = timedata(odata)
    docref = docref.replace('tmp/vinvoice', f'tmp/{scac}/data/vinvoice')
    return odata, cdata, sdata, oder, peep, serv, err, modata, modlink, fdata, today, inco, leftscreen, docref, leftsize, ldata, monsel, monvec, invo, invooder, invojo, cache, filesel, bm, cm, invodate
Beispiel #10
0
class Game(object):
    """Ядро игры"""
    __obj = None

    input_function = get_input_function()

    storage = Storage()

    @classmethod
    def __new__(cls, *args):
        if cls.__obj is None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    @classmethod
    def start(cls, *args):
        """запуск игры"""
        clear_screen()

        #инициализация 2-х игроков
        while (len(cls.storage.players) < 2):
            player = cls.construct_player(len(cls.storage.players) + 1)
            cls.storage.players.append(player)
            clear_screen()

        player = cls.storage.players[0]
        enemy = cls.storage.players[1]
        if player is None or enemy is None:
            raise Exception('Игроки не были созданы!')

        hit_result_message = ''
        while True:
            try:
                if hit_result_message != '':
                    clear_screen()
                    print(hit_result_message + '\n')
                    hit_result_message = ''

                cls.print_field(enemy.field.data, True)
                coord = cls.get_coords('Игрок {}, Ваш ход: '.format(
                    player.name))
                hit = enemy.hit(coord)
                if hit == 2:
                    if enemy.total_hits() == 0:
                        print('Игрок {} победил!'.format(player.name))
                        return
                    hit_result_message = 'Игрок {} потопил корабль противника!!! Можете сделать еще один выстрел!'.format(
                        player.name)
                elif hit == 1:
                    hit_result_message = 'Игрок {} попал по кораблю противника!!! Можете сделать еще один выстрел!'.format(
                        player.name)
                else:
                    hit_result_message = 'Игрок {} промахнулся и ход переходит к {}!!!'.format(
                        player.name, enemy.name)
                    player, enemy = enemy, player

            except Exception as e:
                clear_screen()
                print(e + '\n')

    @staticmethod
    def get_name(number):
        """
        Запрос имени игрока
        number - номер игрока
        """
        while True:
            name = Game.input_function(
                'Игрок № {}, введите свое имя: '.format(number))
            if name == '':
                continue
            return name

    @staticmethod
    def get_coords(input_message):
        """
        Запрос координат
        input_message - отображаемое сообщение
        """
        while (True):
            user_input = Game.input_function(input_message)
            try:
                coords = user_input.split(",")
                if len(coords) != 2:
                    raise Exception(
                        "Некорректные данные. Слишко много, или мало координат."
                    )

                return Coord(int(coords[0]) - 1, int(coords[1]) - 1)

            except ValueError:
                print("Некорректные данные. Для ввода допустимы только цифры")
            except Exception as e:
                print(e)
            print()

    @staticmethod
    def get_direction(input_message):
        """
        Запрос ориентации корабля
        input_message - отображаемое сообщение
        """
        while (True):
            user_input = Game.input_function(input_message)
            try:
                if user_input not in ('В', 'Г'):
                    raise Exception("Некорректные данные.")
                return user_input
            except Exception as e:
                print(e)
                print()

    def get_printable_row(row, hidden):
        """
        Возвращает представление строки поля
        row - строка (данные)
        hidden - прятать корабли, или нет
        """
        mask = [' ', ' ', 'X', '*', ' '
                ] if hidden else [' ', '$', 'X', '*', ' ']
        r = []
        for i in row:
            r.append(mask[i])
        return r

    @staticmethod
    def print_field(field, hidden):
        """
        Печать игрового поля
        field - поле
        hidden - прятать корабли, или нет
        """
        print(' ' * 6 +
              ('{:4}' * 10).format(*tuple(range(1, Storage.field_size + 1))))
        print(' ' * 7 + '-' * 41)
        for y in range(Storage.field_size):
            print('   {:3} |'.format(y + 1) + (' {} |' * 10).format(
                *tuple(Game.get_printable_row(field[y], hidden))))
            print(' ' * 7 + '-' * 41)

    @classmethod
    def construct_player(cls, *args):
        """Создание игрока"""

        name = cls.get_name(args[0])
        player = Player(name)

        print('Привет, {}, давай заполним твое поле'.format(name))

        for s in cls.storage.ships:
            i = 0
            while (i < s.quantity):
                try:
                    #запрашиваем левую верхнюю координату корабля
                    coord1 = cls.get_coords(
                        'Введите координаты для корабля {} № {} в формате "столбец,строка":'
                        .format(s.name, i + 1))
                    coord2 = Coord(coord1.x, coord1.y)

                    #запрашиваем способ расположения корабля только для многоклеточных
                    if s.size > 1:
                        direction = cls.get_direction(
                            'Укажите расположение корабля, вертикальное (В), или горизонтальное (Г): [В|Г]'
                        )
                        if direction == 'В':
                            coord2.y += s.size
                        elif direction == 'Г':
                            coord2.x += s.size

                    #создаем корабль игрока
                    ship = Ship(s.name, s.size, coord1, coord2)
                    player.add_ship(ship)
                    i += 1
                    clear_screen()
                    Game.print_field(player.field.data, False)

                except Exception as e:
                    print(e)

        player.field.clean_aura()
        return player
Beispiel #11
0
__author__ = 'sobolevn'

app = Flask(__name__, template_folder='templates')
app.config.from_object(config)


@app.route('/', methods=['GET', 'POST'])
def home():
    storage = Storage()

    if request.method == 'POST':
        form = BlogPostForm(request.form)
        if form.validate():
            model = BlogPostModel(form.data)
            storage.appending(model.model_to_dict())
        else:
            logger.error('Someone have submitted an incorrect form!')
    else:
        form = BlogPostForm()
    return render_template(
        'home.html',
        form=form,
        items=storage.posts,
    )


if __name__ == '__main__':
    Storage()
    app.run()
Beispiel #12
0
 def test_object_without_file(self):
     # An object without a file has limited functionality.
     obj = Storage()
     self.assertEqual(repr(obj.normal), '<FieldFile: None>')
     self.assertRaises(ValueError, getattr, obj.normal, 'size')
Beispiel #13
0
 def test_directory_determined_once(self):
     # Verify the fix for #5655, making sure the directory is only
     # determined once.
     obj = Storage()
     obj.random.save('random_file', ContentFile('random content'))
     self.assertEqual(obj.random.read(), 'random content')
Beispiel #14
0
def make_obj():
    obj = Storage()
    obj.normal.save('django_test.txt', ContentFile('content'))
    return obj
Beispiel #15
0
 def post(self):
     data = request.json
     url = Storage(url=data['url'], limit=data['limit'])
     db.session.add(url)
     db.session.commit()
     return id_schema.dump(url)
Beispiel #16
0
from models import Storage, Event
from base import Base

# initialize mysql storage
Storage().init_storage()

# get events
base = Base()
operation = 'listEvents/'
payload = '{"filter":{"eventTypeIds":["1"]}}'
data = base.retrieve(operation, payload)  # list of dicts
events = []
for event in data:
    events.append(Event(event))