public async Task <IEnumerable <TransactionPrioritySmartSort> > GetSmartSortForTransactionPriorityAsync(Guid transPriorityKey)
{
return(await DbSet?.Where(s => s.TransPriorityKey == transPriorityKey)?.Select(x => new TransactionPrioritySmartSort()
{
SmartSortColumnKey = x.SmartSortColumnKey.ToString(), SmartSortName = x.SmartSortColumnKeyNavigation.ColumnNameText, SmartSortOrder = x.SmartSortOrder
})?.ToListAsync());
}
private void WriteSalesByVendor(
XmlTextWriter writer, DbSet<Models.Sale> sales, Models.Vendor vendor)
{
writer.WriteStartElement("sale");
writer.WriteAttributeString("vendor", vendor.VendorName);
foreach (var date in sales.Where(s => s.Product.VendorID == vendor.ID)
.Select(s => s.Date).Distinct().ToList())
{
writer.WriteStartElement("summary");
writer.WriteAttributeString("date", date.ToShortDateString());
writer.WriteAttributeString("total-sum", sales.Where(s => s.Date == date &&
s.Product.VendorID == vendor.ID).Sum(s => s.Sum).ToString());
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public async Task PutSmartSortForTransactionPriorityIdSmartSortIdAsync(Guid transPriorityKey, Guid smartSortId, SmartSort transactionPrioritySmartSortPut)
{
var smartSort = DbSet?.Where(s => s.TransPriorityKey == transPriorityKey && s.SmartSortColumnKey == smartSortId).FirstOrDefault();
smartSort.SmartSortOrder = transactionPrioritySmartSortPut.SmartSortOrder;
smartSort.LastModifiedByActorKey = transactionPrioritySmartSortPut.LastModifiedByActorKey;
smartSort.LastModifiedUTCDateTime = transactionPrioritySmartSortPut.LastModifiedUTCDateTime;
DbSet.Update(smartSort);
}
internal IQueryable<Submission> GetFilteredSubmissions(DbSet<Submission> submissions, string[] filter)
{
if (filter == null || filter.Length == 0)
{
filter = new [] { "sfw" };
}
return submissions.Where(x => filter.Any(f => f.ToLower() == x.Tag.ToString().ToLower()));
}
public async Task <List <T> > GetAllAsync()
{
return(await DbSet.Where(E => !E.IsDelete).ToListAsync());
}
private static void FixBankAccountsAndMeetings(ref DbSet<BankAccount> bankAccountSet, ref DbSet<Meeting> meetingSet)
{
Meeting[] meetings = meetingSet.Where(m => m.Finished > DateTime.Now).ToArray();
BankAccount[] bankAccounts = bankAccountSet.Where(ba => ba.Token != "V2-1-0-21").ToArray();
foreach (Meeting meeting in meetings)
{
BankAccountType bankAccountType;
switch (meeting.MeetingType)
{
case MeetingType.Lgs:
case MeetingType.WorkshopyBi:
case MeetingType.Leaders:
case MeetingType.MspEvening:
bankAccountType = BankAccountType.LgsOrMspEveningOrWorkshopsOrLeaders;
break;
case MeetingType.SetkaniTymu:
bankAccountType = BankAccountType.TeamMeeting;
break;
case MeetingType.SkoleniDavidaKotaska:
bankAccountType = BankAccountType.DavidKotasekTraining;
break;
case MeetingType.Ostatni:
bankAccountType = BankAccountType.Others;
break;
default:
throw new ArgumentOutOfRangeException();
}
BankAccount bankAccount = bankAccounts.FirstOrDefault(ba => ba.CurrencyType == CurrencyType.CZK && ba.BankAccountType == bankAccountType);
if (bankAccount == null)
continue;
meeting.BankAccountId = bankAccount.BankAccountId;
}
bankAccounts = bankAccountSet.Where(ba => ba.Title == String.Empty && ba.Token != "V2-1-0-21").ToArray();
foreach (BankAccount bankAccount in bankAccounts)
{
bankAccount.Title = bankAccount.BankAccountTypeLocalizedText;
bankAccount.Owner = bankAccount.BankAccountTypeLocalizedText;
}
bankAccounts = bankAccountSet.Where(ba => ba.Token == "V2-1-0-21").ToArray();
foreach (BankAccount bankAccount in bankAccounts)
{
bankAccountSet.Remove(bankAccount);
}
}
public static IQueryable <Settings> GetSettings(this DbSet <Settings> settings, long?chatId)
{
return(settings
.Where(_ => _.Chat == chatId)
.OrderBy(_ => _.Order));
}
public TEntity Get(string id)
{
return(DbSet.Where(o => o.Id == id).FirstOrDefault());
}
/// <summary>
/// Finds entities satisfied with query command
/// </summary>
/// <param name="queryObject">Query command</param>
/// <returns>Entites</returns>
public IEnumerable <T> FindBy(IQueryCommand <T> queryObject)
{
return(Set
.Where(queryObject.Predicate)
.ToList());
}
public IEnumerable <T> GetMany(Func <T, bool> where)
{
return(dbset.Where(where).AsQueryable());
}
public IEnumerable <T> Get(Expression <Func <T, bool> > predicate)
{
return(_dbSet.Where(predicate));
}
/// <summary>
/// Gets project categories by given projectid
/// </summary>
public Task <List <ProjectCategory> > GetProjectCategories(int projectId)
{
return(DbSet.Where(p => p.Project.Id == projectId).ToListAsync());
}
public IEnumerable <T> Find(Func <T, bool> predicate)
{
return(table.Where(predicate));
}
/// <summary>
/// Gets project category by given category id
/// </summary>
public Task <ProjectCategory> GetProjectCategory(int categoryId)
{
return(DbSet.Where(p => p.Category.Id == categoryId)
.FirstOrDefaultAsync());
}
public virtual IEnumerable <TEntity> Find(Expression <Func <TEntity, bool> > filter)
{
return(DbSet.Where(filter).ToList());
}
public IEnumerable <TEntity> Buscar(Expression <Func <TEntity, bool> > predicate)
{
return(DbSet.Where(predicate));
}
private string ValidateContractorData(DbSet<Contractor> dbSet, Contractor contractor, bool isNew)
{
if (String.IsNullOrEmpty(contractor.Name))
return "Имя пользователя обязательно";
if (String.IsNullOrEmpty(contractor.Code))
return "Отображаемое имя обязательно";
if (isNew)
{
Contractor item = dbSet.Where(x =>
String.Compare(x.Code, contractor.Code, StringComparison.OrdinalIgnoreCase) == 0
|| x.Name == contractor.Name).FirstOrDefault<Contractor>();
if (item != null)
return "Контрагент с таким именем существует";
}
else
{
Contractor item = (from x in dbSet
where x.ContractorId == contractor.ContractorId
select x).First<Contractor>();
// if DisplayName was changed
if (item.Name.ToLower() != contractor.Name.ToLower())
{
if ((from x in dbSet
where String.Compare(x.Name, contractor.Name, StringComparison.OrdinalIgnoreCase) == 0
select x).FirstOrDefault<Contractor>() != null)
return "Контрагент с таким именем существует";
}
// if UserName was changed
if (item.Code.ToLower() != contractor.Code.ToLower())
{
if ((from x in dbSet
where String.Compare(x.Code, contractor.Code, StringComparison.OrdinalIgnoreCase) == 0
select x).FirstOrDefault<Contractor>() != null)
return "Контрагент с таким именем существует";
}
}
if (!String.IsNullOrEmpty(contractor.Email))
{
if (!ValidationHelper.IsValidEmail(contractor.Email))
return "Неверный формат email";
}
return String.Empty;
}
public List <T> GetSome(Expression <Func <T, bool> > @where)
{
return(_dbSet.Where(where).AsNoTracking().ToList());
}
public List <T> List(Expression <Func <T, bool> > express)
{
//IQueryAble
return(_objectSet.Where(express).ToList());
}
public IEnumerable <TEntity> Listar(Expression <Func <TEntity, bool> > predicate)
{
return(entidade.Where(predicate));
}
public IEnumerable <Safe> GetAll()
{
return(_safeEntity.Where(x => x.IsHidden == false).AsEnumerable());
}
public async Task <Endereco> RetornarEndereco(int Id)
{
return(_Endereco.Where(x => x.IdEndereco == Id).FirstOrDefault());
}
public async Task <IEnumerable <ClientClaim> > GetByClientId(string clientId)
{
return(await DbSet.Where(s => s.Client.ClientId == clientId).ToListAsync());
}
public List <GroupSparepartStockCard> RetrieveFIFOCurrentSparepart(DateTime dateFrom, DateTime dateTo, int sparepartId)
{
var result = from sp in DbSet
where sp.ParentStockCard.PurchaseDate >= dateFrom && sp.ParentStockCard.PurchaseDate <= dateTo &&
(sparepartId > 0 ? sp.ParentStockCard.SparepartId == sparepartId : true)
group sp by new
{
sp.ParentStockCard.Sparepart,
sp.ParentStockCard.SparepartId,
sp.Purchasing,
sp.PurchasingId,
sp.SparepartManualTransaction,
sp.SparepartManualTransactionId
} into gsp
select new GroupSparepartStockCard
{
LastPurchaseDate = gsp.FirstOrDefault().Purchasing != null?gsp.FirstOrDefault().Purchasing.Date : gsp.FirstOrDefault().SparepartManualTransaction.CreateDate,
Sparepart = gsp.Key.Sparepart,
SparepartId = gsp.Key.SparepartId,
PricePerItem = gsp.LastOrDefault().PricePerItem,
TotalQtyFirst = gsp.FirstOrDefault().QtyFirst,
TotalQtyFirstPrice = gsp.FirstOrDefault().QtyFirstPrice,
TotalQtyIn = gsp.Sum(g => g.QtyIn),
TotalQtyInPrice = gsp.Sum(g => g.QtyInPrice),
TotalQtyOut = gsp.Sum(g => g.QtyOut),
TotalQtyOutPrice = gsp.Sum(g => g.QtyOutPrice),
TotalQtyLast = gsp.LastOrDefault().QtyLast,
TotalQtyLastPrice = gsp.LastOrDefault().QtyLastPrice
};
List <GroupSparepartStockCard> reportResult = result.ToList();
//check if there are sparepartID not in range of filter, just fill with totalqtyfirst from the day close to start date filter
if (sparepartId == 0)
{
var listSparepartID = DbSet.Select(x => x.ParentStockCard.SparepartId).Distinct();
if (reportResult == null || reportResult.Count() == 0)
{
reportResult = new List <GroupSparepartStockCard>();
foreach (var itemSparepartID in listSparepartID)
{
SparepartStockCardDetail firstInitData = DbSet.Where(x => x.ParentStockCard.SparepartId == itemSparepartID && x.ParentStockCard.PurchaseDate < dateFrom).LastOrDefault();
if (firstInitData != null)
{
GroupSparepartStockCard newItem = new GroupSparepartStockCard();
newItem.TotalQtyFirst = firstInitData.QtyLast;
newItem.TotalQtyFirstPrice = firstInitData.QtyLastPrice;
reportResult.Add(newItem);
}
}
}
else if (reportResult.Count != listSparepartID.Count())
{
foreach (var itemSparepartID in listSparepartID)
{
if (reportResult.Where(x => x.SparepartId == itemSparepartID).Count() == 0)
{
SparepartStockCardDetail firstInitData = DbSet.Where(x => x.ParentStockCard.SparepartId == itemSparepartID && x.ParentStockCard.PurchaseDate < dateFrom).LastOrDefault();
if (firstInitData != null)
{
GroupSparepartStockCard newItem = new GroupSparepartStockCard();
newItem.TotalQtyFirst = firstInitData.QtyLast;
newItem.TotalQtyFirstPrice = firstInitData.QtyLastPrice;
reportResult.Add(newItem);
}
}
}
}
}
else
{
if (reportResult == null || reportResult.Count() == 0)
{
reportResult = new List <GroupSparepartStockCard>();
SparepartStockCardDetail firstInitData = DbSet.Where(x => x.ParentStockCard.SparepartId == sparepartId && x.ParentStockCard.PurchaseDate < dateFrom).LastOrDefault();
if (firstInitData != null)
{
GroupSparepartStockCard newItem = new GroupSparepartStockCard();
newItem.TotalQtyFirst = firstInitData.QtyLast;
newItem.TotalQtyFirstPrice = firstInitData.QtyLastPrice;
reportResult.Add(newItem);
}
}
}
return(reportResult);
}
public virtual T Get(Expression <Func <T, bool> > predicate)
{
return(_dbSet.Where(predicate).SingleOrDefault());
}
public IQueryable <T> FindByCondition(Expression <Func <T, bool> > expression)
{
return(_dbSet.Where(expression));
}
public void RemoveByItemIdAsync(int id)
{
var elements = DbSet.Where(_ => _.AvatarItemId == id);
DbSet.RemoveRange(elements);
}
async Task <IEnumerable <CityFrom> > IRepository <CityFrom, int> .Get(Func <CityFrom, bool> predicate)
{
IEnumerable <CityFrom> cities = await Task.Factory.StartNew(() => _dbSet.Where(predicate).ToList() as IEnumerable <CityFrom>);
return(cities);
}
public bool createSomeWorkers(int numWorkers, DbSet<Worker> workers)
{
for (int i = numWorkers; i >= 0; --i)
{
Person _per = (Person)Records.person.Clone();
Worker _wkr = (Worker)Records.worker.Clone();
Random rnd = new Random();
while (workers.Where(q => q.dwccardnum == _wkr.dwccardnum).Count() > 0)
{
_wkr.dwccardnum = rnd.Next(30000, 32000);
}
//personCreate(_per);
_wkr.ID = _per.ID;
//workerCreate(_wkr, SolutionDirectory() + "\\Machete.test\\jimmy_machete.jpg");
}
return true;
}
public async Task <T> GetUserInfoAsync(Expression <Func <T, bool> > condition)
{
var userInfo = await _dbSet.Where(condition).SingleOrDefaultAsync();
return(userInfo);
}
private string ValidateUsersData(DbSet<UserProfile> dbSet, UserProfile profile, bool isNew)
{
if (String.IsNullOrEmpty(profile.UserName))
return "Имя пользователя обязательно";
if (String.IsNullOrEmpty(profile.DisplayName))
return "Отображаемое имя обязательно";
if (isNew)
{
UserProfile item = dbSet.Where(x =>
String.Compare(x.DisplayName, profile.DisplayName, StringComparison.OrdinalIgnoreCase) == 0
|| x.UserName == profile.UserName).FirstOrDefault<UserProfile>();
if (item != null)
return "Пользователь с таким именем существует";
}
else
{
UserProfile item = (from x in dbSet
where x.UserId == profile.UserId
select x).First<UserProfile>();
// if DisplayName was changed
if (item.DisplayName.ToLower() != profile.DisplayName.ToLower())
{
if ((from x in dbSet
where x.DisplayName == profile.DisplayName
select x).FirstOrDefault<UserProfile>() != null)
return "Пользователь с таким именем существует";
}
// if UserName was changed
if (item.UserName.ToLower() != profile.UserName.ToLower())
{
if ((from x in dbSet
where x.UserName == profile.UserName
select x).FirstOrDefault<UserProfile>() != null)
return "Пользователь с таким именем существует";
}
}
if (!String.IsNullOrEmpty(profile.UserEmail))
{
if (!ValidationHelper.IsValidEmail(profile.UserEmail))
return "Неверный формат email";
}
return String.Empty;
}
public IQueryable <T> GetAll(Expression <Func <T, bool> > predicate)
{
return(_dbSet.Where(predicate));
}
private static void FixMeetingTitleTypesAndMeetings(ref DbContext dbContext, ref DbSet<MeetingTitleType> meetingTitleTypeSet, ref DbSet<Meeting> meetingSet)
{
var meetingTitleType = meetingTitleTypeSet.FirstOrDefault(mtts => mtts.Title == "ST");
if (meetingTitleType == null)
{
meetingTitleType = new MeetingTitleType
{
MeetingType = MeetingType.SetkaniTymu,
Title = "ST"
};
meetingTitleTypeSet.AddOrUpdate(meetingTitleType);
}
else
{
meetingTitleType.MeetingType = MeetingType.SetkaniTymu;
}
dbContext.SaveChanges();
// Nastavit defaultní název setkání týmu
meetingTitleType = meetingTitleTypeSet.First(mtt => mtt.Title == "ST");
Meeting[] meetings = meetingSet.Where(m => m.MeetingType == MeetingType.SetkaniTymu && !m.MeetingTitleTypeId.HasValue).ToArray();
if (meetings.Length == 0)
return;
foreach (Meeting meeting in meetings)
{
meeting.MeetingTitleTypeId = meetingTitleType.MeetingTitleTypeId;
}
}
public async Task <GarmentEMKLModel> ReadByIdAsync(int id)
{
return(await _DbSet.Where(w => w.Id == id).FirstOrDefaultAsync());
}
private IQueryable<LabelEntity> GetLabelEntity(DbSet<LabelEntity> labels, Label label)
{
if (!string.IsNullOrEmpty(label.Name))
{
return labels.Where(it => it.SiteName == label.Site.FullName && it.Name == label.Name && it.Category == (label.Category ?? ""));
}
else
{
return labels.Where(it => it.SiteName == label.Site.FullName && it.UUID == label.UUID);
}
}
public async Task <List <T> > FindAsync(Expression <Func <T, bool> > predicate)
{
return(await Entities.Where(predicate).ToListAsync());
}
private string ValidateProductData(DbSet<Product> dbSet, Product product, bool isNew)
{
if (String.IsNullOrEmpty(product.Article))
return "Артикул товара обязателен";
if(product.Supplier == null)
return "Не указан поставщик товара";
if (isNew)
{
Product item = dbSet.Where(x =>
String.Compare(x.Article, product.Article, StringComparison.OrdinalIgnoreCase) == 0
&& x.ContractorId == product.Supplier.ContractorId).FirstOrDefault<Product>();
if (item != null)
return "Товар с таким артикулом существует";
product.CreatedAt = DateTime.Now;
}
else
{
Product item = (from x in dbSet
where x.ProductId == product.ProductId
select x).First<Product>();
// if Article was changed
if (item.Article.ToLower() != product.Article.ToLower())
{
if ((from x in dbSet
where String.Compare(x.Article, product.Article, StringComparison.OrdinalIgnoreCase) == 0
select x).FirstOrDefault<Product>() != null)
return "Товар с таким артикулом существует";
}
product.ModifiedAt = DateTime.Now;
}
return String.Empty;
}
public List <TEntity> GetALL(System.Linq.Expressions.Expression <Func <TEntity, bool> > predicate)
{
return(dbSet.Where(predicate).ToList());
}
public async Task <IEnumerable <Country> > GetByAbbreviation(string abbreviation)
{
return(await DbSet.Where(c => !string.IsNullOrEmpty(c.Abbreviation)).ToListAsync());
}
private void GetFilteredInfo(string start, string end, int id, IQueryable<Group> groups, DbSet<Classroom> classrooms, out IQueryable<Group> filteredGroups, out IQueryable<Classroom> filteredClassrooms)
{
DateTime startDt = Convert.ToDateTime(start);
DateTime endDt = Convert.ToDateTime(end);
//Find any overlapping events
var overlapping = db.GroupInstances.
Where(period =>
((period.StartDateTime > startDt && period.EndDateTime < endDt)
|| (period.EndDateTime > startDt && period.EndDateTime < endDt)
|| (period.StartDateTime < startDt && period.EndDateTime > endDt)
|| (period.StartDateTime < startDt && period.EndDateTime > endDt))
&& period.GroupInstanceId != id).ToList();
var overlappingGroups = overlapping.Select(x => x.GroupId).ToList();
filteredGroups = groups.Where(x => !overlappingGroups.Contains(x.GroupId));
var overlappingClassrooms = overlapping.Select(x => x.ClassroomId).ToList();
filteredClassrooms = classrooms.Where(x => !overlappingClassrooms.Contains(x.ClassroomID));
}
