Ejemplo n.º 1
0
        public static async void SyncHeaderDetailsInServer()
        {
            try
            {
                UserDialogs.Instance.ShowLoading("Data Syncing...");
                var result = await HeaderRepo.Get <List <InspectionHeaderTable> >(x => x.NewEntry == true || x.Updated == true);

                if (result != null)
                {
                    foreach (var item in result)
                    {
                        InspectionHeadersRequestDTO inspectionHeaderRequestDTO = new InspectionHeadersRequestDTO()
                        {
                            Id                     = item.NewEntry ? 0 : (int)item.Id,
                            CompanyId              = (int)item.CompanyId,
                            InspectionDate         = item.InspectionDate,
                            UserId                 = item.UserId,
                            Invoice                = item.Invoice,
                            ProducerId             = (int)item.ProducerId,
                            VarietyId              = (int)item.VarietyId,
                            BrandId                = (int)item.BrandId,
                            CountryofOriginId      = item.CountryofOriginId,
                            TotalBoxQuantities     = item.TotalBoxQuantities,
                            TempOnCaja             = item.TempOnCaja,
                            TempOnTermografo       = item.TempOnTermografo,
                            PalletizingConditionId = item.PalletizingConditionId,
                        };
                        var resultWeb = await webServiceManager.RegistrationInspectionHeaderAsync(inspectionHeaderRequestDTO).ConfigureAwait(true);

                        if (resultWeb.IsSuccess && resultWeb.Data.StatusCode == 0)
                        {
                            var resultDetailsInner = await DetailsRepo.Get <List <InspectionDetailTable> >(x => (x.NewEntry == true || x.Updated == true) && x.InspectionHeaderId == item.Id);

                            item.NewEntry = false;
                            item.Updated  = false;
                            await HeaderRepo.DeleteItemAsync(x => x.Id == item.Id);

                            item.Id = resultWeb.Data.Id;
                            await HeaderRepo.UpdateItemAsync(item);

                            Console.WriteLine("header data sync : " + resultWeb.Data.Id);

                            if (resultDetailsInner != null)
                            {
                                foreach (var itemInner in resultDetailsInner)
                                {
                                    InspectionDetailsRequestDTO inspectionRequestDTO = new InspectionDetailsRequestDTO()
                                    {
                                        Id = itemInner.NewEntry ? 0 : (int)itemInner.Id,
                                        InspectionHeaderId = resultWeb.Data.Id,
                                        SizeId             = itemInner.SizeId,
                                        SampleSize         = itemInner.SampleSize,
                                        Weight             = itemInner.Weight,
                                        PhysicalCount      = itemInner.PhysicalCount,
                                        OpeningApperenceId = itemInner.OpeningApperenceId,
                                        Temperature        = itemInner.Temperature,
                                        Brix               = itemInner.Brix,
                                        Firmness           = itemInner.Firmness,
                                        SkinDamage         = itemInner.SkinDamage,
                                        Color              = itemInner.Color,
                                        PackageConditionId = itemInner.PackageConditionId,
                                        Comment            = itemInner.Comment,
                                        QualityScore       = itemInner.QualityScore
                                    };
                                    var resultInnerWeb = await webServiceManager.RegistrationInspectionDetailsAsync(inspectionRequestDTO).ConfigureAwait(true);

                                    if (resultInnerWeb.IsSuccess && resultInnerWeb.Data.StatusCode == 0)
                                    {
                                        itemInner.NewEntry = false;
                                        itemInner.Updated  = false;
                                        if (itemInner.Id == 0)
                                        {
                                            await DetailsRepo.DeleteItemAsync(x => x.Id == resultInnerWeb.Data.Id &&
                                                                              x.InspectionHeaderId == resultWeb.Data.Id);

                                            itemInner.Id = resultInnerWeb.Data.Id;
                                            itemInner.InspectionHeaderId = resultWeb.Data.Id;
                                            await DetailsRepo.InsertItemAsync(itemInner);
                                        }
                                        else
                                        {
                                            itemInner.Id = resultInnerWeb.Data.Id;
                                            itemInner.InspectionHeaderId = resultWeb.Data.Id;
                                            await DetailsRepo.UpdateItemAsync(itemInner);
                                        }
                                        Console.WriteLine("details data sync : " + resultInnerWeb.Data.Id);
                                    }
                                }
                            }
                        }
                    }
                }
                var resultDetails = await DetailsRepo.Get <List <InspectionDetailTable> >(x => x.NewEntry == true || x.Updated == true);

                if (resultDetails != null)
                {
                    foreach (var item in resultDetails)
                    {
                        InspectionDetailsRequestDTO inspectionRequestDTO = new InspectionDetailsRequestDTO()
                        {
                            Id = item.NewEntry ? 0 : (int)item.Id,
                            InspectionHeaderId = item.InspectionHeaderId,
                            SizeId             = item.SizeId,
                            SampleSize         = item.SampleSize,
                            Weight             = item.Weight,
                            PhysicalCount      = item.PhysicalCount,
                            OpeningApperenceId = item.OpeningApperenceId,
                            Temperature        = item.Temperature,
                            Brix               = item.Brix,
                            Firmness           = item.Firmness,
                            SkinDamage         = item.SkinDamage,
                            Color              = item.Color,
                            PackageConditionId = item.PackageConditionId,
                            Comment            = item.Comment,
                            QualityScore       = item.QualityScore
                        };
                        var resultWeb = await webServiceManager.RegistrationInspectionDetailsAsync(inspectionRequestDTO).ConfigureAwait(true);

                        if (resultWeb.IsSuccess && resultWeb.Data.StatusCode == 0)
                        {
                            item.NewEntry = false;
                            item.Updated  = false;
                            if (item.Id == resultWeb.Data.Id)
                            {
                                await DetailsRepo.UpdateItemAsync(item);
                            }
                            else
                            {
                                await DetailsRepo.DeleteItemAsync(x => x.Id == item.Id &&
                                                                  x.InspectionHeaderId == item.InspectionHeaderId);

                                item.Id = resultWeb.Data.Id;
                                await DetailsRepo.InsertItemAsync(item);
                            }
                            Console.WriteLine("details data sync : " + resultWeb.Data.Id);
                        }
                    }
                }
                UserDialogs.Instance.HideLoading();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error in Data Syncing in Server:" + ex.Message);
                UserDialogs.Instance.HideLoading();
            }
        }
Ejemplo n.º 2
0
        static async Task SyncHeaderDetails()
        {
            InspectionHeadersRequestDTO headerRequestDTO = new InspectionHeadersRequestDTO()
            {
                CompanyId = Convert.ToInt32(RememberMe.Get("CmpID")),
                UserId    = Convert.ToInt32(RememberMe.Get("userID")),
            };
            var result = await webServiceManager.GetHeaderbyID(headerRequestDTO).ConfigureAwait(true);

            if (result.IsSuccess)
            {
                if (result.Data.InspectionHeader != null && result.Data.InspectionHeader.Count > 0)
                {
                    InspectionHeaderList = new ObservableCollection <InspectionHeaderTable>();
                    foreach (var data in result.Data.InspectionHeader)
                    {
                        InspectionHeaderList.Add(new InspectionHeaderTable
                        {
                            Id                     = data.Id,
                            CompanyId              = data.CompanyId,
                            InspectionDate         = data.InspectionDate,
                            UserId                 = data.UserId,
                            Invoice                = data.Invoice,
                            ProducerId             = data.ProducerId,
                            VarietyId              = data.VarietyId,
                            BrandId                = data.BrandId,
                            CountryofOriginId      = data.CountryofOriginId,
                            TotalBoxQuantities     = data.TotalBoxQuantities,
                            TempOnCaja             = data.TempOnCaja,
                            TempOnTermografo       = data.TempOnTermografo,
                            PalletizingConditionId = data.PalletizingConditionId,
                        });
                    }
                }
                await HeaderRepo.DeleteAllAsync <InspectionHeaderTable>();

                await HeaderRepo.InsertAll(InspectionHeaderList);

                var resultDetails = await webServiceManager.GetHeaderDetailsAll().ConfigureAwait(true);

                if (resultDetails.IsSuccess)
                {
                    if (resultDetails.Data.InspectionDetail != null && resultDetails.Data.InspectionDetail.Count > 0)
                    {
                        InspectionDetailsList = new ObservableCollection <InspectionDetailTable>();

                        foreach (var data in resultDetails.Data.InspectionDetail)
                        {
                            InspectionDetailsList.Add(new InspectionDetailTable
                            {
                                Id = data.Id,
                                InspectionHeaderId = data.InspectionHeaderId,
                                SizeId             = data.SizeId,
                                SampleSize         = data.SampleSize,
                                Weight             = data.Weight,
                                PhysicalCount      = data.PhysicalCount,
                                OpeningApperenceId = data.OpeningApperenceId,
                                Temperature        = data.Temperature,
                                Brix               = data.Brix,
                                Firmness           = data.Firmness,
                                SkinDamage         = data.SkinDamage,
                                Color              = data.Color,
                                PackageConditionId = data.PackageConditionId,
                                Comment            = data.Comment,
                                QualityScore       = data.QualityScore,
                            });
                        }
                    }
                    await DetailsRepo.DeleteAllAsync <InspectionDetailTable>();

                    await DetailsRepo.InsertAll(InspectionDetailsList);
                }
            }
            else
            {
                Console.WriteLine("Prolem in header and details sync");
            }
        }