public async Task <DataSet> GetInfoAsync(string dataSet)
{
var token = await GetTokenAsync();
var info = await $"https://api.domo.com/v1/datasets/{dataSet}"
.WithOAuthBearerToken(token.access_token)
.GetJsonAsync <DataSet>();
info.schema.columns = info.schema.columns
.Select(column => {
column.name = Slugify.ToSlug(column.name);
return(column);
})
.Select(column => {
int i = 0;
while (info.schema.columns.Count(c => c.name == column.name) > 1)
{
column.name = $"{column.name}-{i}";
}
return(column);
})
.ToList();
return(info);
}
public ActionResult Create(HttpPostedFileBase avatarFile, FlavorViewModel flavorViewModel)
{
if (ModelState.IsValid)
{
Flavor flavor = new Flavor()
{
UserId = ((Customer)Session["Customer"]).Id,
UserType = Flavor.CUSTOMER,
Name = flavorViewModel.Name,
Description = flavorViewModel.Description,
Images = SaveImages.SaveImagesFile(avatarFile, flavorViewModel.Name),
PreparationTime = flavorViewModel.PreparationTime,
TotalTime = flavorViewModel.TotalTime,
Ingredients = flavorViewModel.Ingredients,
Recipe = flavorViewModel.Recipe,
IsApproved = false,
Slug = Slugify.GenerateSlug(flavorViewModel.Name),
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
Session["Image"] = "/" + ConfigurationManager.AppSettings["CusImages"] + flavor.Images;
db.Flavors.Add(flavor);
db.SaveChanges();
return(RedirectToAction("Flavors", "Customer"));
}
return(View());
}
public ActionResult Edit(HttpPostedFileBase avatarFile, FlavorViewModel flavorVM)
{
try
{
var flavor = db.Flavors.Find(flavorVM.Id);
if (flavor.IsApproved == true)
{
return(RedirectToAction("Flavors", "Customer"));
}
flavor.Name = flavorVM.Name;
if (avatarFile != null)
{
flavor.Images = SaveImages.SaveImagesFile(avatarFile, flavorVM.Name);
}
flavor.Description = flavorVM.Description;
flavor.PreparationTime = flavorVM.PreparationTime;
flavor.TotalTime = flavorVM.TotalTime;
flavor.Ingredients = flavorVM.Ingredients;
flavor.Slug = Slugify.GenerateSlug(flavor.Name);
flavor.UpdatedAt = DateTime.Now;
flavor.Recipe = flavorVM.Recipe;
flavor.IsApproved = false;
db.Entry(flavor).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Flavors", "Customer"));
}
catch
{
return(View());
}
}
public ActionResult Create(BookCategoryViewModel model)
{
if (ModelState.IsValid)
{
var check = db.BookCategories.Where(x => x.Name == model.Name).FirstOrDefault();
if (check == null)
{
BookCategory bookCategory = new BookCategory()
{
Name = model.Name,
Slug = Slugify.GenerateSlug(model.Name),
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
db.BookCategories.Add(bookCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ViewBag.statusCheck = "Name already exists";
}
}
return(View());
}
public ActionResult Create(HttpPostedFileBase avatarFile, FlavorViewModel flavorVM)
{
try
{
Flavor flavor = new Flavor()
{
UserId = ((Staff)Session["Staff"]).Id,
UserType = Flavor.STAFF,
Name = flavorVM.Name,
Description = flavorVM.Description,
Images = SaveImages.SaveImagesFile(avatarFile, flavorVM.Name),
PreparationTime = flavorVM.PreparationTime,
TotalTime = flavorVM.TotalTime,
Ingredients = flavorVM.Ingredients,
Recipe = flavorVM.Recipe,
IsApproved = true,
Slug = Slugify.GenerateSlug(flavorVM.Name),
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
Session["Image"] = "/" + ConfigurationManager.AppSettings["CusImages"] + flavor.Images;
db.Flavors.Add(flavor);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
private void SeedBookCategories()
{
var categories = Builder <BookCategory> .CreateListOfSize(10)
.All()
.With(c => c.Name = string.Join(" ", Faker.Lorem.Words(3)))
.With(c => c.Slug = Slugify.GenerateSlug(string.Join(" ", Faker.Lorem.Words(3))))
.With(c => c.CreatedAt = DateTime.Now)
.With(c => c.UpdatedAt = DateTime.Now)
.With(c => c.DeletedAt = null)
.With(c => c.DeletedBy = null)
.Build();
db.BookCategories.AddRange(categories);
db.SaveChanges();
}
public async Task AddAsync(Report report)
{
var collection = await GetCollection();
report.Slug = Slugify.ToSlug(report.Name);
var slugNumber = 0;
while (await GetAsync(report.Slug) != null)
{
slugNumber++;
report.Slug = $"{report.Slug}-{slugNumber}";
}
await collection.InsertOneAsync(report);
}
public ActionResult Edit(HttpPostedFileBase avatarFile, BookViewModel viewModel)
{
SetViewBag(viewModel.CategoryId);
if (ModelState.IsValid)
{
var book = db.Books.Where(x => x.Id == viewModel.Id).FirstOrDefault();
book.Name = viewModel.Name;
book.Price = viewModel.Price;
book.Slug = Slugify.GenerateSlug(viewModel.Name);
book.CategoryId = viewModel.CategoryId;
book.Images = SaveImages.SaveImagesFile(avatarFile, viewModel.Name);
book.Description = viewModel.Description;
book.Discount = viewModel.Discount;
book.UpdatedAt = DateTime.Now;
db.Entry(book).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public ActionResult Create(HttpPostedFileBase avatarFile, BookViewModel viewModel)
{
SetViewBag();
if (ModelState.IsValid)
{
Random rd = new Random();
var book = MappingProfile.mapper.Map <BookViewModel, Book>(viewModel);
book.StaffId = ((Staff)Session["Staff"]).Id;
book.Slug = Slugify.GenerateSlug(book.Name);
book.CreatedAt = DateTime.Now;
book.UpdatedAt = DateTime.Now;
book.Sku = rd.Next(1000, 9999).ToString();
book.Images = SaveImages.SaveImagesFile(avatarFile, viewModel.Name);
db.Books.Add(book);
db.SaveChanges();
}
;
return(RedirectToAction("Index"));
}
public ActionResult Create(LevelViewModel model)
{
try
{
db.Levels.Add(new Level()
{
Name = model.Name,
Key = Slugify.GenerateSlug(model.Name),
Permissions = db.Permissions.Where(q => model.Permissions.Contains(q.Id)).ToList(),
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
});
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(RedirectToAction("Create"));
}
}
public ActionResult Edit(BookCategoryViewModel model)
{
if (ModelState.IsValid)
{
var check = db.BookCategories.Where(x => x.Name == model.Name).FirstOrDefault();
if (check == null)
{
var category = db.BookCategories.Where(x => x.Id == model.Id).FirstOrDefault();
category.Name = model.Name;
category.Slug = Slugify.GenerateSlug(model.Name);
category.UpdatedAt = DateTime.Now;
db.Entry(category).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ViewBag.statusCheck = "Name already exists";
}
}
return(View());
}
public ActionResult AddBlogPost(BlogPostVM model)
{
if (ModelState.IsValid)
{
BlogPost blogpost = new BlogPost();
blogpost.Title = model.Title;
blogpost.Content = model.Content;
blogpost.CategoryID = model.CategoryID;
blogpost.Slug = Slugify.Generate(model.Title);
foreach (string name in Request.Files)
{
string number = Guid.NewGuid().ToString();
string ext = Path.GetExtension(model.AnaResim.FileName);
model.AnaResim = Request.Files[name];
if (ext == ".jpg" || ext == ".png" || ext == ".jpeg")
{
string filename = number + model.AnaResim.FileName;
blogpost.ImagePath = filename;
model.AnaResim.SaveAs(Server.MapPath("~/Areas/Admin/Content/images/BlogPost/" + number + model.AnaResim.FileName));
}
}
db.BlogPost.Add(blogpost);
db.SaveChanges();
ViewBag.IslemDurum = 1;
return(View(drpCategories()));
}
else
{
ViewBag.IslemDurum = 3;
return(View(drpCategories()));
}
}
public ActionResult Edit(LevelViewModel model, int id)
{
var level = db.Levels.Find(id);
if (level == null)
{
return(HttpNotFound());
}
foreach (Permission permission in level.Permissions.ToList())
{
level.Permissions.Remove(permission);
}
level.Name = model.Name;
level.Key = Slugify.GenerateSlug(model.Name);
level.UpdatedAt = DateTime.Now;
level.Permissions = db.Permissions.Where(q => model.Permissions.Contains(q.Id)).ToList();
db.Entry(level).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <string> GenerateAsync(Report report, GenerationSettings settings)
{
string key = $"{DateTime.Now.ToString("yyyy-MM-dd/yyyy-MM-dd_HH-mm-ss")}_{Guid.NewGuid()}.zip";
await mongoReportGenerationRepository.AddAsync(new ReportGeneration()
{
Slug = report.Slug,
Name = key,
Status = "Pending"
});
try
{
var data = await domoService.GetDataAsync(report, settings);
string url = string.Empty;
// TODO factor this to another file to make this class testable
var tempPath = Path.GetTempFileName();
using (var tempFile = File.Create(tempPath))
using (var zipArchive = new ZipArchive(tempFile, ZipArchiveMode.Create))
{
foreach (var group in data)
{
var convertedData = ConvertToData(group.Value);
var documents = reportingCloudRepository.GenerateReport(report, convertedData);
// count on the order of items in the JArray and in the original group to be the same, to figure out filenames
// single sanity check: counts should be the same
var renameFiles = false;
var uniqueFilenamesSet = new HashSet <string>();
if (documents.Count == convertedData.Count)
{
renameFiles = true;
}
for (var i = 0; i < documents.Count; i++)
{
var document = documents[i];
string filename;
if (renameFiles)
{
var groupedValues = group
.Value
.Values
.ElementAt(i)
.Item1
.Values;
filename = string.Join("_", groupedValues
.Skip(groupedValues.Count - settings.ChildGroups.Count)
.Select(value => Slugify.ToSlug(value)));
if (uniqueFilenamesSet.Contains(filename))
{
filename = $"{filename}_{Guid.NewGuid().ToString()}";
}
else
{
uniqueFilenamesSet.Add(filename);
}
}
else
{
filename = Guid.NewGuid().ToString();
}
var zipEntry = zipArchive.CreateEntry($"{group.Key}/{filename}.pdf");
using (var zipStream = zipEntry.Open())
using (var stream = new MemoryStream(document))
await stream.CopyToAsync(zipStream);
}
}
}
url = await s3Service.UploadAsync(tempPath, key);
await mongoReportGenerationRepository.UpdateAsync(new ReportGeneration()
{
Name = key,
Status = "Success"
});
return(url);
}
catch (Exception)
{
await mongoReportGenerationRepository.UpdateAsync(new ReportGeneration()
{
Name = key,
Status = "Failed"
});
throw;
}
}
