示例#1
0
        private static string WriteCateg(IBaseEntityCategory entity)
        {
            StringBuilder result = new StringBuilder();

            //var file = File.Create("Categories.txt");
            using (StreamWriter sw = new StreamWriter("Categories.txt", true))
            {
                foreach (ITranslationEntity stri in entity.Categotis.Keys)
                {
                    // file.Write(Encoding.UTF8.GetBytes(stri.Value), 0, Encoding.UTF8.GetBytes(stri.Value).Length);
                    sw.WriteLine(stri.Value);
                }
            }

            return(result.ToString());
        }
示例#2
0
        private static string WriteWord(IBaseEntityCategory entity)
        {
            StringBuilder result = new StringBuilder();

            using (StreamWriter sw = new StreamWriter("Words.txt", true))
            {
                foreach (var list in entity.Categotis.Values)
                {
                    if (list.ItemEntity?.TranslationItemEntitys != null)
                    {
                        foreach (var s in list.ItemEntity?.TranslationItemEntitys)
                        {
                            foreach (var val in s.WordTranslations.Where(p => p.Language == "en"))
                            {
                                sw.WriteLine(val.Value);
                            }
                        }
                    }
                }
            }

            return(result.ToString());
        }
示例#3
0
        public async Task InitDb(string path)
        {
            IDataResult <IBaseEntityCategory> dataResult = _normalizeData.Normalize(path);

            return;

            if (!dataResult.Success)
            {
                return;
            }

            IBaseEntityCategory excelProcessingEntity = dataResult.Data;

            foreach (KeyValuePair <ITranslationEntity, IParsedResultEntity> parsedResultEntity in
                     excelProcessingEntity.Categotis)
            {
                string fullName =
                    LanguageHolder.GetLanguage(parsedResultEntity.Key.Language);

                if (fullName != null)
                {
                    await AppendLangDictionary(parsedResultEntity.Key.Language, fullName);

                    IDataResult <int> checkCategoryExistResult =
                        await CheckCategoryExist(parsedResultEntity.Key);

                    int categoryId;

                    if (checkCategoryExistResult.Success)
                    {
                        categoryId = checkCategoryExistResult.Data;
                    }
                    else
                    {
                        var category = new Category()
                        {
                            ImgPath = ""
                        };

                        await _categoryRepository.AddAsync(category);

                        await _categoryRepository.SaveAsync();

                        categoryId = category.Id;
                    }

                    IDataResult <List <string> > existingLanguageResult =
                        await CheckLanguagesExists(categoryId);

                    List <string> existingLanguage = existingLanguageResult.Data;

                    if (existingLanguage != null &&
                        existingLanguage.All(p => p != parsedResultEntity.Key.Language))
                    {
                        await _categoryTranslationRepository.AddAsync(new CategoryTranslation()
                        {
                            CategoryId        = categoryId,
                            IsMainTranslation = true,
                            LangDictionaryId  = parsedResultEntity.Key.Language,
                            CategoryName      = parsedResultEntity.Key.Value
                        });

                        await _categoryTranslationRepository.SaveAsync();
                    }

                    foreach (ITranslationEntity translationEntity in parsedResultEntity.Value.CategoryTranslate)
                    {
                        if (existingLanguage != null &&
                            //existingLanguage.Any() &&
                            existingLanguage.All(p => p != translationEntity.Language))
                        {
                            await _categoryTranslationRepository.AddAsync(new CategoryTranslation()
                            {
                                CategoryId        = categoryId,
                                IsMainTranslation = false,
                                LangDictionaryId  = translationEntity.Language,
                                CategoryName      = translationEntity.Value
                            });

                            await _categoryTranslationRepository.SaveAsync();
                        }
                    }


                    //проверь сдесь значения на налл Вордтранслейшен именно я пока курить

                    IDataResult <int> checImageDictionaryExistResult = new DataResult <int>();

                    if (parsedResultEntity.Value?.ItemEntity?.MainSection?.WordTranslation != null)
                    {
                        checImageDictionaryExistResult =
                            await CheckImgDictionaryExist(parsedResultEntity.Value.ItemEntity.MainSection
                                                          .WordTranslation);

                        int imagDictionaryId;

                        if (checImageDictionaryExistResult.Success)
                        {
                            imagDictionaryId = checkCategoryExistResult.Data;
                        }
                        else
                        {
                            var imageDictionary = new ImageDictionary()
                            {
                                DisplayAtProgram = true,
                                CategoryId       = categoryId,
                                RootImageId      = null
                            };

                            await _imageDictionaryRepository.AddAsync(imageDictionary);

                            await _imageDictionaryRepository.SaveAsync();

                            imagDictionaryId = imageDictionary.Id;
                        }

                        IDataResult <List <string> > existingImageLanguageResult =
                            await CheckImageLanguagesExists(imagDictionaryId);

                        List <string> existingImgLangs = existingImageLanguageResult.Data;

                        if (parsedResultEntity.Value?.ItemEntity?.MainSection?.WordTranslation != null)
                        {
                            fullName =
                                LanguageHolder.GetLanguage(parsedResultEntity.Value.ItemEntity.MainSection
                                                           .WordTranslation
                                                           .Language);

                            //if (fullName != null)
                            //{
                            //    await AppendLangDictionary(
                            //        parsedResultEntity.Value.ItemEntity.MainSection.WordTranslation.Language, fullName);
                            //    if (existingImgLangs != null &&
                            //        existingImgLangs.All(p =>
                            //            p != parsedResultEntity.Value.ItemEntity.MainSection.WordTranslation.Language))
                            //    {
                            //        var mainImageDescriptionItem =
                            //            parsedResultEntity.Value.ItemEntity.MainSection;
                            //        await _imageDescriptionRepository.AddAsync(new ImageDescription()
                            //        {
                            //            ImageDictionaryId = imagDictionaryId,
                            //            IsMainTranslation = true,
                            //            LangDictionaryId = mainImageDescriptionItem.WordTranslation.Language,
                            //            Description = mainImageDescriptionItem.WordTranslation.Value
                            //        });

                            //        await _imageDescriptionRepository.SaveAsync();
                            //    }
                            //}

                            foreach (var imgDictionaryItem in parsedResultEntity.Value.ItemEntity.TranslationItemEntitys)
                            {
                                ImageDictionary itemForUpdate =
                                    await _imageDictionaryRepository.GetByIdAsync(imagDictionaryId);

                                itemForUpdate.SexType = imgDictionaryItem.SexType;
                                await _imageDictionaryRepository.UpdateAsync(itemForUpdate);

                                await _imageDictionaryRepository.SaveAsync();

                                foreach (ITranslationEntity translationEntity in imgDictionaryItem.WordTranslations)
                                {
                                    fullName =
                                        LanguageHolder.GetLanguage(translationEntity.Language);
                                    if (fullName != null)
                                    {
                                        await AppendLangDictionary(
                                            translationEntity.Language, fullName);

                                        if (existingImgLangs != null &&
                                            existingImgLangs.All(p =>
                                                                 p != translationEntity.Language)
                                            )
                                        {
                                            if (translationEntity.Language != parsedResultEntity.Value.ItemEntity
                                                .MainSection.WordTranslation.Language)
                                            {
                                                await _imageDescriptionRepository.AddAsync(new ImageDescription()
                                                {
                                                    ImageDictionaryId = imagDictionaryId,
                                                    IsMainTranslation = false,
                                                    LangDictionaryId  = translationEntity.Language,
                                                    Description       = translationEntity.Value
                                                });
                                            }
                                            else
                                            {
                                                await _imageDescriptionRepository.AddAsync(new ImageDescription()
                                                {
                                                    ImageDictionaryId = imagDictionaryId,
                                                    IsMainTranslation = true,
                                                    LangDictionaryId  = translationEntity.Language,
                                                    Description       = translationEntity.Value
                                                });
                                            }

                                            await _imageDescriptionRepository.SaveAsync();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }