public override void OnBindElements(View view)
        {
            AddGoodsDispatchedNoteInvoiceId    = view.FindViewById <AutoCompleteTextView>(Resource.Id.AddGoodsDispatchedNoteInvoiceId);
            AddGoodsDispatchedNoteDocumentId   = view.FindViewById <EditText>(Resource.Id.AddGoodsDispatchedNoteDocumentId);
            AddGoodsDispatchedNoteIssueDate    = view.FindViewById <EditText>(Resource.Id.AddGoodsDispatchedNoteIssueDate);
            AddGoodsDispatchedNoteDispatchDate = view.FindViewById <EditText>(Resource.Id.AddGoodsDispatchedNoteDispatchDate);

            AddGoodsDispatchedNoteInvoiceId.AfterTextChanged        += AfterTextChanged;
            AddGoodsDispatchedNoteIssueDate.OnFocusChangeListener    = this;
            AddGoodsDispatchedNoteDispatchDate.OnFocusChangeListener = this;
            _dialog = CreateDatePickerDialog(this);

            _addGoodsDispatchedNoteAdapter = new AddGoodsDispatchedNoteAdapter(Context, LocationService);
            _invoiceAdapter = new BaseArrayAdapter <Models.Invoice>(Context);

            InvoiceFilterCriteria = new InvoiceFilterCriteria
            {
                ItemsPerPage   = 5,
                InvoiceType    = InvoiceType.Sales,
                AssignedToNote = false
            };

            var currentDate       = DateTime.Now;
            var currentDateFormat = currentDate.ToLongDateString();

            AddGoodsDispatchedNoteIssueDate.Text    = currentDateFormat;
            AddGoodsDispatchedNoteIssueDate.Tag     = new JavaObjectWrapper <DateTime>(currentDate);
            AddGoodsDispatchedNoteDispatchDate.Text = currentDateFormat;
            AddGoodsDispatchedNoteDispatchDate.Tag  = new JavaObjectWrapper <DateTime>(currentDate);
            AddGoodsDispatchedNoteDocumentId.Text   = string.Format("WZ/{0:yyyyMMddhhmmss}", currentDate);
        }
        public async Task <List <Invoice> > GetInvoices(string accountId)
        {
            List <Invoice>        ret      = new List <Invoice>();
            InvoiceFilterCriteria criteria = new InvoiceFilterCriteria();

            try
            {
                criteria.AccountId = accountId;
                RestRequestSpecification req = new RestRequestSpecification();
                req.Verb        = HttpMethod.Get;
                req.RequestUri  = $"/v2/invoices?criteria.accountId={accountId}";
                req.Headers     = Headers;
                req.ContentType = "application/json";
                var returnPost = await asyncRestClientBilling.ExecuteAsync <string>(req);

                if (returnPost.Success)
                {
                    ret = JsonSerializer.Deserialize <List <Invoice> >(returnPost.Value.ToString());
                }
                else
                {
                    ret = null;
                }
            }
            catch (Exception ex)
            {
                log.Fatal(ex);
                ret = null;
            }
            return(ret);
        }
        public override void OnItemsLoad(CancellationToken token)
        {
            InvoiceFilterCriteria = new InvoiceFilterCriteria
            {
                ItemsPerPage = 10
            };

            _adapter = new InvoiceRowItemAdapter(Context, RoleManager);
            _adapter.IOnClickListener = this;

            ItemList.SetAdapter(_adapter);

            Task.Run(async() =>
            {
                await GetItems(token);
            }, token);
        }
Example #4
0
        public IEnumerable <Invoice> Get(InvoiceFilterCriteria criteria)
        {
            var query = _sqliteConnection
                        .GetAllWithChildren <Invoice>()
                        .Skip(criteria.ItemsPerPage * criteria.Page)
                        .Take(criteria.ItemsPerPage);

            if (criteria.InvoiceType.HasValue)
            {
                query.Where(inv => inv.InvoiceType == criteria.InvoiceType.Value);
            }

            if (!string.IsNullOrEmpty(criteria.Name))
            {
                query.Where(inv => inv.DocumentId == criteria.Name);
            }

            return(query);
        }
        public List <Common.DTO.Invoice> GetInvoices(InvoiceFilterCriteria criteria)
        {
            var result = InvoiceRepository.Entities;

            if (criteria.InvoiceType.HasValue)
            {
                result = result.Where(en => en.InvoiceType == criteria.InvoiceType.Value);
            }

            if (!string.IsNullOrEmpty(criteria.Name))
            {
                result = result.Where(en => en.DocumentId.Contains(criteria.Name));
            }

            return(result
                   .Skip(criteria.Page * criteria.ItemsPerPage)
                   .Take(criteria.ItemsPerPage)
                   .Select(_mapper.Map)
                   .ToList());
        }
Example #6
0
        public async Task <HttpResult <List <Invoice> > > GetInvoices(InvoiceFilterCriteria criteria, CancellationToken token = default(CancellationToken))
        {
            var result = new HttpResult <List <Invoice> >();

            try
            {
                result.Data = _unitOfWork
                              .GetInvoices(criteria)
                              .Select(inv => new Invoice
                {
                    DocumentId = inv.DocumentId,
                    IssueDate  = inv.IssueDate,
                    Products   = inv.Products
                                 .Select(pr => new Entry
                    {
                        Id    = pr.Id,
                        Name  = pr.Name,
                        Price = pr.Price,
                        VAT   = pr.VAT,
                        Count = pr.Count
                    })
                                 .ToList(),
                    PaymentMethod  = inv.PaymentMethod,
                    InvoiceType    = inv.InvoiceType,
                    CompletionDate = inv.CompletionDate,
                    CreatedAt      = inv.CreatedAt,
                    LastModifiedAt = inv.LastModifiedAt,
                    Note           = inv.Note
                })
                              .ToList();
            }
            catch (Exception ex)
            {
            }



            return(result);
        }
        public List <Common.DTO.Invoice> GetInvoices(InvoiceFilterCriteria criteria)
        {
            IEnumerable <Invoice> entities = InvoiceRepository
                                             .Get(criteria);

            entities = entities.Select(inv =>
            {
                inv.GoodsDispatchedNote = GoodsDispatchedNoteRepository.Get(inv.Id);
                inv.GoodsReceivedNote   = GoodsReceivedNoteRepository.Get(inv.Id);
                inv.City              = CityRepository.Get(inv.CityId);
                inv.Counterparty      = CounterpartyRepository.Get(inv.CounterpartyId);
                inv.Counterparty.City = CityRepository.Get(inv.Counterparty.CityId);
                inv.Products          = EntryRepository.GetForInvoice(inv.Id);
                return(inv);
            });

            if (criteria.AssignedToNote.HasValue)
            {
                if (criteria.AssignedToNote.Value)
                {
                    entities = entities
                               .Where(inv => inv.GoodsReceivedNote != null ||
                                      inv.GoodsDispatchedNote != null);
                }
                else
                {
                    entities = entities
                               .Where(inv => inv.GoodsReceivedNote == null &&
                                      inv.GoodsDispatchedNote == null);
                }
            }

            return(entities
                   .Select(_mapper.Map)
                   .ToList());
        }
 public async Task <HttpResult <List <Models.Invoice> > > GetInvoices(InvoiceFilterCriteria criteria, CancellationToken token = default(CancellationToken))
 {
     return(await PostPaged <Models.Invoice>(criteria, token));
 }
        public async Task <IActionResult> GetInvoices([FromBody] InvoiceFilterCriteria criteria)
        {
            var entities = _unitOfWork.GetInvoices(criteria);

            return(new ObjectResult(entities));
        }