public async Task <ActionResult <CollectionViewModel <Department> > > Get(
string company,
[FromQuery] string selectedCompanies,
[FromQuery] PagingOptions pagingOptions,
[FromQuery] string code = null,
[FromQuery] string description = null,
[FromQuery] bool includeDeactivated = false)
{
bool flag = false;
var header = this.HttpContext.Request.Headers;
var referer = header.FirstOrDefault(k => k.Key == "Referer");
if (referer.Key != null && referer.Value.ToString().ToLower().Contains("/admin/users"))
{
flag = true;
}
if (!string.IsNullOrEmpty(company) && !string.IsNullOrEmpty(selectedCompanies))
{
company = selectedCompanies + ',' + company;
}
var departments = await _departmentRepository.GetAllAsync(company.Split(','), code, pagingOptions.Offset, null, flag, includeDeactivated, description);
var response = new CollectionViewModel <Department>(departments.ToList());
return(Ok(response));
}
public async Task <ActionResult> DeleteCollection(Guid id)
{
HttpRequestMessage apiRequest = CreateRequestToService(HttpMethod.Get, $"Collections/{id}");
HttpResponseMessage apiResponse;
try
{
apiResponse = await HttpClient.SendAsync(apiRequest);
}
catch
{
return(RedirectToAction("CollectionDetails", id));
}
if (!apiResponse.IsSuccessStatusCode)
{
return(RedirectToAction("CollectionDetails", id));
}
CollectionViewModel collection = await apiResponse.Content.ReadAsAsync <CollectionViewModel>();
PassCookiesToClient(apiResponse);
var user = await WhoAmI();
if (collection.OwnerId != user.Id)
{
TempData["Message"] = "Please log in.";
return(RedirectToAction("Login", "Accounts"));
}
return(View(collection));
}
public ActionResult Edit(CollectionViewModel collectionViewModel)
{
try
{
if (ModelState.IsValid)
{
var collection = Mapper.Map <Collection>(collectionViewModel);
db.Entry(collection).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch (DbUpdateConcurrencyException)
{
//This is implemented by a virtue of having "RowVersion" field in our model and database. watch this video for details: https://youtu.be/Gi_kEbc5faQ
ModelState.AddModelError(string.Empty, $"The record you've been trying to update was modified by another user. Please go back and try again.");
}
catch (DataException dex)
{
ModelState.AddModelError(string.Empty, $"Database Error occured Copy the error message and send it to Dima </br>: {dex.Message}. + {dex.InnerException.Message} + {dex.InnerException.InnerException.Message}");
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, $"Unexpected error occured. Copy the error message and send it to Dima {ex.Message} | {ex.InnerException.InnerException.Message}" +
$"{ex.InnerException.InnerException.Message}");
}
ViewBag.TabletID = new SelectList(db.Tablets, "ID", "TabletName", collectionViewModel.TabletID);
return(View(collectionViewModel));
}
public ActionResult Submitted(int Id, string IndexType, string UserRemark, string IsContinue, string GenGatePass)
{
LedgerHeader pd = _CollectionService.Find(Id);
CollectionViewModel s = _CollectionService.GetCollection(Id);
if (ModelState.IsValid)
{
if (User.Identity.Name == pd.ModifiedBy || UserRoles.Contains("Admin"))
{
try
{
_CollectionService.Submit(Id, User.Identity.Name, GenGatePass, UserRemark);
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
TempData["CSEXC"] += message;
return(RedirectToAction("Index", new { id = pd.DocTypeId, PersonId = s.PersonId }));
}
}
else
{
return(RedirectToAction("Index", new { id = pd.DocTypeId, PersonId = s.PersonId, IndexType = IndexType }).Warning("Record can be submitted by user " + pd.ModifiedBy + " only."));
}
}
return(RedirectToAction("Index", new { id = pd.DocTypeId, PersonId = s.PersonId, IndexType = IndexType }));
}
// GET: /LedgerHeader/Create
public ActionResult Create(int id, int PersonId)//DocumentTypeId
{
CollectionViewModel p = new CollectionViewModel();
PropertyHeaderViewModel propertyheader = _PropertyHeaderService.GetPropertyHeader(PersonId);
p = Mapper.Map <PropertyHeaderViewModel, CollectionViewModel>(propertyheader);
p.DocDate = DateTime.Now;
p.CreatedDate = DateTime.Now;
p.DivisionId = (int)System.Web.HttpContext.Current.Session["DivisionId"];
p.SiteId = (int)System.Web.HttpContext.Current.Session["SiteId"];
p.DocTypeId = id;
p.AgentDocTypeId = Constants.DocumentTypeIdConstants.Agent;
PrepareViewBag(id);
var settings = _CollectionSettingsService.GetCollectionSettingsForDocument(id);
p.CollectionSettings = Mapper.Map <CollectionSettings, CollectionSettingsViewModel>(settings);
p.DocNo = _documentTypeService.FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", p.DocTypeId, p.DocDate, p.DivisionId, p.SiteId);
ViewBag.Mode = "Add";
ViewBag.Name = _documentTypeService.Find(id).DocumentTypeName;
ViewBag.id = id;
return(View(p));
}
public ActionResult Detail(int id, string IndexType, string transactionType, int?DocLineId)
{
if (DocLineId.HasValue)
{
ViewBag.DocLineId = DocLineId;
}
//Saving ViewBag Data::
ViewBag.transactionType = transactionType;
ViewBag.IndexStatus = IndexType;
CollectionViewModel s = _CollectionService.GetCollection(id);
var settings = _CollectionSettingsService.GetCollectionSettingsForDocument(s.DocTypeId);
s.CollectionSettings = Mapper.Map <CollectionSettings, CollectionSettingsViewModel>(settings);
PrepareViewBag(s.DocTypeId);
if (s == null)
{
return(HttpNotFound());
}
if (String.IsNullOrEmpty(transactionType) || transactionType == "detail")
{
_CollectionService.LogDetailInfo(s);
}
return(View("Create", s));
}
public ActionResult Business(CollectionViewModel model)
{
DB db = new DB();
BusinessRecord record = db.BusinessRecords.Find(model.Id);
OfficialReceipt or = new OfficialReceipt();
or.BusinessRecord = record;
or.ORDate = model.orDate;
or.ORNumber = model.orNumber;
or.changeAmount = model.changeAmount;
or.totalAmount = model.payableAmount;
or.tenderedAmount = model.tenderedAmount;
List <Fee> fees = new List <Fee>();
if (model.isNew)
{
fees = db.Fees.Include(x => x.Status).Where(x => x.StatusId != 2).ToList();
}
else
{
fees = db.Fees.Include(x => x.Status).Where(x => x.StatusId != 1).ToList();
}
or.FeesPaid = fees;
db.OfficialReceipts.Add(or);
DateTime paidDate = DateTime.Now;
record.BusinessDetail.lastPayDate = paidDate;
record.isCollected = model.quarter;
if (record.isCollected >= 4)
{
record.BusinessDetail.isNew = false;
}
db.SaveChanges();
return(Redirect("/Issuance/Business/" + record.UniqueId));
}
public async Task <ActionResult <CollectionViewModel <ChildSectionsSearchResultDto> > > GetChileSectionData(
string company,
EntitySearchRequest searchRequest)
{
long sectionId = 0;
string sectionRef = null;
foreach (var clause in searchRequest.Clauses.Clauses)
{
if (clause.FieldId == 0)
{
sectionId = long.Parse(clause.Value1, CultureInfo.InvariantCulture);
}
else
{
sectionRef = clause.Value1;
}
}
IEnumerable <ChildSectionsSearchResultDto> tradeReportContracts = await _sectionQueries.GetTradeChildSectionDataAsync(company, sectionId, sectionRef);
var response = new CollectionViewModel <ChildSectionsSearchResultDto>(tradeReportContracts.ToList());
return(Ok(response));
}
public ActionResult Create(HttpPostedFileBase file, CollectionViewModel c, FormCollection collection)
{
//Get the selected values ID from the category dropdown list
int id = Convert.ToInt32(collection["listbox"]);
if (file != null && file.ContentLength > 0)
{
try
{
string path = Path.Combine(Server.MapPath("/Content/Img"),
Path.GetFileName(file.FileName));
file.SaveAs(path);
ViewBag.Message = "File uploaded successfully";
c.Cd.Image = "~/Content/Img/" + file.FileName;
c.Cd.Genre = new CdReference.Genre()
{
ID = id
};
c.Cd.User = new CdReference.UserTable {
ID = userId
};
cdObj.AddCd(c.Cd);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.Message = "ERROR:" + ex.Message.ToString();
}
}
else
{
ViewBag.Message = "You have not specified a file.";
}
return(null);
}
public void Reset_NewViewModel_CollectionReplaced()
{
// Arrange
Utils.PlayerDummy m = new Utils.PlayerDummy();
Utils.PlayerDummy modelNotified = null;
CollectionViewModel <Utils.PlayerDummy, DummyPlayerVM> collection = new CollectionViewModel <Utils.PlayerDummy, DummyPlayerVM> ();
collection.ViewModels.Add(new DummyPlayerVM {
Model = m
});
Utils.PlayerDummy mToUpdate = new Utils.PlayerDummy();
var vmToUpdate = new DummyPlayerVM {
Model = mToUpdate
};
// Act
collection.ViewModels.Reset(new List <DummyPlayerVM> {
vmToUpdate
});
// Assert
Assert.AreEqual(1, collection.ViewModels.Count());
}
public ActionResult Edit(long?id)
{
if (!id.HasValue)
{
return(SendJsonErrorResponse("Collection ID was not specified"));
}
var collection = repository.GetProductCollection(id.Value, subdomainid.Value);
if (collection == null)
{
return(SendJsonErrorResponse("Invalid Collection ID specified"));
}
var products = repository.GetProducts(subdomainid.Value);
var productList = collection.productCollectionMembers.Select(x => x.productid).ToArray();
var viewmodel = new CollectionViewModel
{
id = collection.id,
permalink = collection.permalink,
visible = ((CollectionSettings)collection.settings).HasFlag(CollectionSettings.VISIBLE),
details = collection.details,
title = collection.name,
fullUrl = accountHostname.ToDomainUrl("/collections/" + collection.permalink),
products = products.ToBaseModel(),
productids = string.Join(",", productList)
};
return(View(viewmodel));
}
public void CollectionController_Get_Basic()
{
//ARRANGE
var collectionId = Guid.NewGuid();
var controller = MockUtils.MockProperties <CollectionsController>();
var collectionViewModel = new CollectionViewModel()
{
Id = collectionId, Name = "Collection 543"
};
Mock.Get(controller.CollectionFacade).Setup(x => x.GetById(collectionId)).Returns(
new CollectionDto()
{
Id = collectionId, Name = collectionViewModel.Name
}
);
Mock.Get(controller.Mapper).Setup(x => x.Map <CollectionViewModel>(It.Is <CollectionDto>(p => p is CollectionDto && p.Id == collectionId && p.Name == "Collection 543"))).Returns(collectionViewModel);
//ACT
var collection = controller.Get(collectionId).Value as CollectionViewModel;
//ASSERT
Assert.AreEqual(collectionId, collection.Id);
Assert.AreEqual("Collection 543", collection.Name);
}
public async Task <IActionResult> Create(CollectionViewModel model, string username)
{
if (ModelState.IsValid)
{
User user = await _userManager.FindByNameAsync(username);
Collection collection = new Collection {
Name = model.Name, Theme = model.Theme, Summary = model.Summary, Owner = user.UserName, UserId = user.Id, CountItems = 0, Img = model.Img
};
if (model.Img != null)
{
await UploadFile(collection);
}
else
{
collection.UrlImg = "/images/Collections/" + model.Theme + ".jpg";
collection.ImageStorageName = model.Theme;
}
CreateActivity(CREATECOl, collection.Owner);
_context.Collections.Add(collection);
await _context.SaveChangesAsync();
return(RedirectToAction("ProfileCollections", "Collections", new { name = username }));
}
return(View(model));
}
public async Task <ActionResult> EditCollection(CollectionViewModel collection)
{
HttpRequestMessage apiRequest = CreateRequestToService(HttpMethod.Put, "Collections");
apiRequest.Content = new ObjectContent <CollectionViewModel>(collection, new JsonMediaTypeFormatter());
HttpResponseMessage apiResponse;
try
{
apiResponse = await HttpClient.SendAsync(apiRequest);
}
catch
{
return(RedirectToAction("CollectionDetails", new { id = collection.Id }));
}
if (!apiResponse.IsSuccessStatusCode)
{
return(RedirectToAction("CollectionDetails", new { id = collection.Id }));
}
PassCookiesToClient(apiResponse);
return(RedirectToAction("CollectionDetails", new { id = collection.Id }));
}
// GET: tblItems
public ActionResult Index(int?id)
{
var viewModel = new CollectionViewModel();
viewModel.tblCollection = db.tblCollections;
if (id != null)
{
viewModel.tblItem = db.tblItems.Where(i => i.ColletionID == id.Value);
//ViewBag.Collection = ;
//viewModel.tblItem = viewModel.tblCollection.Where(i => i.CollectionID == id.Value).Single().tblItem;
//viewModel.tblCategory = db.tblCategories;
//var categories = new List<tblCategory>();
//tblCategory eenCategory = new tblCategory();
//viewModel.tblItemCategory = db.tblItems.Where(i => i.ItemID == id.Value).Single().tblItemCategories;
//foreach (tblItemCategory pp in viewModel.tblItemCategory)
//{
// eenCategory = (tblCategory) db.tblCategories.Where(i => i.CategoryID == pp.CategoryID).Single();
// categories.Add(eenCategory);
//}
//viewModel.tblCategory = categories;
}
return(View(viewModel));
}
public CollectionPage()
{
InitializeComponent();
collectionViewModel = new CollectionViewModel();
BindingContext = collectionViewModel;
}
public string GetFilterName(object filtersCollection, FilterItemBase filter)
{
if (filter != null)
{
var count = CollectionViewModel.GetEntities(GetFilterExpression(filter)).Count();
if (count > 0)
{
return(filter.Name + " (" + count + ")");
}
else
{
return(filter.Name);
}
}
else
{
if (object.Equals(filtersCollection, StaticFilters))
{
return(StaticFiltersName);
}
if (object.Equals(filtersCollection, CustomFilters))
{
return(CustomFiltersName);
}
if (object.Equals(filtersCollection, Groups))
{
return(GroupFiltersName);
}
}
return(null);
}
public static Task SimpleCollectionLoad <T>(this CollectionViewModel <T> viewModel, GitHubRequest <List <T> > request, bool forceDataRefresh) where T : new()
{
return(Task.Run(() => viewModel.RequestModel(request, forceDataRefresh, response => {
viewModel.Items.Reset(response.Data);
viewModel.CreateMore(response, m => viewModel.MoreItems = m, d => viewModel.Items.AddRange(d));
})));
}
public void windowsFormHostViewInitialization(Func <IQueryable <TASK> > getTASKsFunc, Func <IQueryable <PROJWBS> > getWBSSFunc,
Func <IQueryable <WORKPACK_Dashboard> > getWORKPACK_DashboardFunc,
CollectionViewModel <WORKPACK_ASSIGNMENT, WORKPACK_ASSIGNMENT, Guid, IBluePrintsEntitiesUnitOfWork> WORKPACKS_ASSIGNMENTSViewModel,
bool IsModified)
{
winFormHost.Child = new PROJECTWORKPACKDetailsMappingView(getTASKsFunc, getWBSSFunc, getWORKPACK_DashboardFunc, WORKPACKS_ASSIGNMENTSViewModel, IsModified);
}
public AddCollectionPage()
{
InitializeComponent();
collectionViewModel = new CollectionViewModel(Navigation);
collectionViewModel.PageList();
BindingContext = collectionViewModel;
}
public void TwoCollectionsOneItemTest()
{
var c1 = new CollectionViewModel();
var c2 = new CollectionViewModel();
var i = new ItemViewModel();
Assert.AreEqual(null, i.Collection);
Assert.AreEqual(0, c1.Count);
Assert.AreEqual(0, c2.Count);
i.Collection = c1;
Assert.AreEqual(c1, i.Collection);
Assert.AreEqual(1, c1.Count);
Assert.AreEqual(0, c2.Count);
i.Collection = c2;
Assert.AreEqual(c2, i.Collection);
Assert.AreEqual(0, c1.Count);
Assert.AreEqual(1, c2.Count);
c1.Add(i);
Assert.AreEqual(c1, i.Collection);
Assert.AreEqual(1, c1.Count);
Assert.AreEqual(0, c2.Count);
}
public async Task <IActionResult> List(string name, [FromQuery] SearchMethod method = SearchMethod.Simple, [FromQuery] string query = null, [FromQuery] bool desc = true, [FromQuery] string skipToken = null, [FromQuery] int limit = 20, [FromQuery] RenderStyle style = RenderStyle.Default)
{
var collection = await _settings.FindCollectionAsync(name);
var items = method == SearchMethod.Simple
? await _data.SearchAsync(name, query, skipToken, limit, desc)
: await _data.QueryAsync(name, query, skipToken, limit, desc);
if (!desc)
{
items = items.Reverse();
}
var model = new CollectionViewModel
{
SearchMethod = method,
SeachQuery = query,
TitlePath = collection.TitlePath,
Items = items,
CollectionName = name,
DisplayName = collection.DisplayName,
Procedures = collection.Procedures ?? new ProcedureInfo[0],
Limit = limit
};
if (style == RenderStyle.NoBlade)
{
return(View("ListNoBlade", model));
}
return(View(model));
}
public ActionResult <CollectionViewModel> Put([FromBody] CollectionViewModel model)
{
try
{
if (ModelState.IsValid)
{
var updateCollection = _mapper.Map <CollectionViewModel, Collection>(model);
_context.Update(updateCollection);
if (_context.SaveChanges() == 1)
{
return(Ok(_mapper.Map <Collection, CollectionViewModel>(updateCollection)));
}
else
{
return(BadRequest("Failed to update the collection"));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
string error = $"Error when updating the Collection: {ex.Message}";
_logger.LogError(error);
return(BadRequest(error));
}
}
public void OneCollectionOneItemTest()
{
var c = new CollectionViewModel();
var i = new ItemViewModel();
Assert.AreEqual(null, i.Collection);
Assert.AreEqual(0, c.Count);
i.Collection = c;
Assert.AreEqual(c, i.Collection);
Assert.AreEqual(1, c.Count);
i.Collection = null;
Assert.AreEqual(null, i.Collection);
Assert.AreEqual(0, c.Count);
c.Add(i);
Assert.AreEqual(c, i.Collection);
Assert.AreEqual(1, c.Count);
c.Remove(i);
Assert.AreEqual(null, i.Collection);
Assert.AreEqual(0, c.Count);
}
public ActionResult <CollectionViewModel> Create([FromBody] CollectionViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newCollection = _mapper.Map <CollectionViewModel, Collection>(model);
_context.Add(newCollection);
if (_context.SaveChanges() == 1)
{
return(Created($"/api/Collection/{newCollection.CollectionId}", _mapper.Map <Collection, CollectionViewModel>(newCollection)));
}
else
{
return(BadRequest("Failed to create the new collection"));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
string error = $"Error when creating the Collection: {ex.Message}";
_logger.LogError(error);
return(BadRequest(error));
}
}
private CollectionViewModel GetCollectionViewModel(long siteID, long year)
{
CollectionViewModel model = new CollectionViewModel();
model.Collection = CollectionRepository.First(c => c.Site.ID == siteID);
model.SiteCoords = string.Format("{0}, {1}", model.Collection.Site.Latitude, model.Collection.Site.Longitude);
List <Photo> photos = PhotoRepository.Find(p => p.Site.ID == model.Collection.Site.ID).OrderBy(p => p.Captured).ToList <Photo>();
if (year != -1)
{
photos = photos.Where(p => p.Captured.Year == year).ToList <Photo>();
}
model.SiteDetails = new SiteDetails()
{
PhotoCount = photos.Count(), First = photos.Select(p => p.Captured).First(), Last = photos.Select(p => p.Captured).Last()
};
Phocalstream_Shared.Data.Model.Photo.User User = UserRepository.First(u => u.ProviderID == this.User.Identity.Name);
if (User != null)
{
UserCollectionList userCollectionModel = new UserCollectionList();
userCollectionModel.User = User;
userCollectionModel.Collections = CollectionRepository.Find(c => c.Owner.ID == User.ID && c.Type == CollectionType.USER, c => c.Photos).ToList();
model.UserCollections = userCollectionModel;
}
return(model);
}
public PROJECTWORKPACKDetailsActivityAssignment(IEnumerable <TASK_AppointmentInfo> AllTASK_Appointments, IEnumerable <WORKPACK_Dashboard> WORKPACKS,
CollectionViewModel <WORKPACK_ASSIGNMENT, WORKPACK_ASSIGNMENT, Guid, IBluePrintsEntitiesUnitOfWork> WORKPACK_ASSIGNMENTSViewModel, bool IsModified, Appointment SelectedTASK_Appointment)
{
InitializeComponent();
this.DataContext = PROJECTWORKPACKAssignmentViewModel.Create(AllTASK_Appointments, WORKPACKS, WORKPACK_ASSIGNMENTSViewModel, IsModified, SelectedTASK_Appointment);
((PROJECTWORKPACKAssignmentViewModel)this.DataContext).RefreshWORKPACK_ASSIGNMENTCallBack = this.RefreshWORKPACK_ASSIGNMENTCallBack;
}
public async Task <IActionResult> Search([Bind("q,PageNumber,SelectedOrder")] CollectionViewModel model)
{
model.PageSize = 50;
var items = _context.Items
.AsNoTracking()
.Include(i => i.ItemCategories)
.ThenInclude(i => i.Category)
.AsQueryable();
if (!string.IsNullOrEmpty(model.q))
{
string[] keywords = model.q.Trim().ToLower().Split(" ");
foreach (string keyword in keywords)
{
items = items.Where(i => i.Name.ToLower().Contains(keyword) ||
i.ItemCategories.Any(ic => ic.Category.Name.ToLower().Contains(keyword)) ||
i.Description.ToLower().Contains(keyword));
}
}
items = items.OrderItemsBy(model.SelectedOrder);
await model.PaginateItems(items);
return(View("Category", model));
}
public async Task <ActionResult <CollectionViewModel <TradeMergeMessageDto> > > GetContextualDataForSelectedContractMerge(string company, string sectionIds, [FromQuery] int?dataVersionId = null)
{
var tradeMergeMessages = await _sectionMergeQueries.GetContextualDataForSelectedContractMergeAsync(company, sectionIds.Split(',').Select(long.Parse).ToArray(), dataVersionId);
var response = new CollectionViewModel <TradeMergeMessageDto>(tradeMergeMessages.ToList());
return(Ok(response));
}
public async Task <ActionResult <CollectionViewModel <EnumEntity> > > Get(string company)
{
IEnumerable <EnumEntity> costTypes = await _postingStatusRepository.GetAllAsync(company);
var response = new CollectionViewModel <EnumEntity>(costTypes.ToList());
return(Ok(response));
}
protected RepositoriesViewModel()
{
Repositories = new CollectionViewModel<RepositoryModel>();
}
public TeamsViewModel()
{
Title = "Teams";
Teams = new CollectionViewModel<TeamShortModel>();
}
public BranchesAndTagsViewModel()
{
Items = new CollectionViewModel<ViewObject>();
this.Bind(x => x.SelectedFilter).Subscribe(x => LoadCommand.Execute(false));
}
