public ActionResult UpdateProjection(ProjectionModel projectionUpdate)
{
if (Session["Username"] == null)
{
return(RedirectToAction("Login", "Login"));
}
else
{
if (projectionUpdate == null)
{
Session["ErrorMessage"] = "Please Update With Valid Details!";
}
if (projectionUpdate != null)
{
var projectionupdate = new ProjectionUpdate()
{
Id = projectionUpdate.Id,
Quantity = projectionUpdate.Quantity,
DateInvoiced = projectionUpdate.DateInvoiced.ToString(),
Comments = projectionUpdate.Comments
};
var IsReturnValid = ProjectionHelperService.EditProjectionModel(projectionupdate);
}
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Index(ProjectionModel ProjectionEntryModel)
{
ProjectionModel model = new ProjectionModel();
if (Session["Username"] == null)
{
return(RedirectToAction("Login", "Login"));
}
else
{
if (ProjectionEntryModel != null)
{
var ProjectionEntryModelRecord = new ProjectionEntryModel()
{
ProjectID = ProjectionEntryModel.ProjectID,
OpportunityID = ProjectionEntryModel.OpportunityID,
WarehouseId = ProjectionEntryModel.WarehouseID,
Quantity = ProjectionEntryModel.Quantity,
Created = ProjectionEntryModel.Created,
DateInvoiced = ProjectionEntryModel.DateInvoiced,
ActivityId = ProjectionEntryModel.ActivityId,
ServiceActivityId = ProjectionEntryModel.ServiceActivityId,
ProjectManagerID = ProjectionEntryModel.ProjectManagerID,
};
var returnstatus = ProjectionHelperService.ProjectionEntryAdd(ProjectionEntryModelRecord);
}
}
return(View(LoadDropDownsServices.ProjectionDropdowns()));
}
public ProjectionModelTests()
{
Services = Substitute.For <IServiceProvider>();
Services.GetService(typeof(ReservationList)).Returns(new ReservationList());
Model = new ProjectionModel(typeof(ReservationList));
Model.AddEventHandler(new EventHandlerModel(Model.Type.FindMethod("On", typeof(FlightReservationCreated)), new EventModel(typeof(FlightReservationCreated))));
Model.AddEventHandler(new EventHandlerModel(Model.Type.FindMethod("On", typeof(FlightReservationCancelled)), new EventModel(typeof(FlightReservationCancelled))));
}
public void subject_delegates_to_the_inner_values()
{
var model = new ProjectionModel();
MockFor <IValues <ProjectionModel> >().Stub(x => x.Subject).Return(model);
ClassUnderTest.Subject.ShouldBeTheSameAs(model);
}
public static List <ReservationModel> SearchReservationByDate(DateTime from, DateTime to)
{
List <ReservationModel> ret = new List <ReservationModel>();
foreach (ReservationModel m in Cinema.Reservations)
{
ProjectionModel tmp = GetProjectionById(m.Projection);
if (tmp.Date >= from && tmp.Date <= to)
{
ret.Add(m);
}
}
return(ret);
}
public bool UpdateProjection(ProjectionModel projectionModel)
{
Projection projection = _context.Projections.Where(x => x.ProjectionId == projectionModel.ProjectionId).FirstOrDefault();
if (projectionModel.FinancialDashboard != null)
{
projection.FinancialDashboardJson = JsonConvert.SerializeObject(projectionModel.FinancialDashboard);
}
projection.ModifiedById = projectionModel.ModifiedById;
projection.ModifiedDate = DateTime.UtcNow;
projection.ProjectionName = projectionModel.ProjectionName;
_context.Entry(projection).State = EntityState.Modified;
_context.SaveChanges();
return(true);
}
public async Task <ActionResult> Put(Guid id, [FromBody] ProjectionModel projectionModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ProjectionDomainModel projectionToUpdate;
projectionToUpdate = await _projectionService.GetProjectionByIdAsync(id);
if (projectionToUpdate == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.PROJECTION_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
projectionToUpdate.MovieId = projectionModel.MovieId;
projectionToUpdate.AuditoriumId = projectionModel.AuditoriumId;
projectionToUpdate.ProjectionTime = projectionModel.ProjectionTime;
ProjectionDomainModel projectionDomainModel;
try
{
projectionDomainModel = await _projectionService.UpdateProjection(projectionToUpdate);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Accepted("movies//" + projectionDomainModel.Id, projectionDomainModel));
}
public ProjectionModel GetProjectionById(int projectionId)
{
Projection projection = _context.Projections.AsNoTracking().Where(x => x.ProjectionId == projectionId).FirstOrDefault();
ProjectionModel projectionModel = new ProjectionModel();
if (projection != null)
{
projectionModel.ProjectionId = projection.ProjectionId;
projectionModel.ProjectionName = projection.ProjectionName;
projectionModel.ClientId = projection.ClientId;
projectionModel.UserId = projection.UserId;
projectionModel.CreatedDate = projection.CreatedDate;
projectionModel.CreatedById = projection.CreatedById;
projectionModel.ModifiedById = projection.ModifiedById;
projectionModel.ModifiedDate = projection.ModifiedDate;
projectionModel.IsActive = projection.IsActive;
projectionModel.FinancialDashboard = JsonConvert.DeserializeObject <FinanclialDashboardModel>(projection.FinancialDashboardJson);
}
return(projectionModel);
}
public ProjectionModel CreateProjection(ProjectionModel projectionModel)
{
Projection projection = new Projection();
projection.ProjectionId = projectionModel.ProjectionId;
projection.ProjectionName = projectionModel.ProjectionName;
projection.ClientId = projectionModel.ClientId;
projection.UserId = projectionModel.UserId;
projection.CreatedDate = DateTime.UtcNow;
projection.CreatedById = projectionModel.CreatedById;
projection.ModifiedById = projectionModel.ModifiedById;
projection.ModifiedDate = null;
projection.IsActive = true;
projection.IsDeleted = false;
projection.FinancialDashboardJson = JsonConvert.SerializeObject(projectionModel.FinancialDashboard);
_context.Projections.Add(projection);
_context.SaveChanges();
projectionModel.ProjectionId = projection.ProjectionId;
return(projectionModel);
}
public static ProjectionModel ProjectionDropdowns()
{
ProjectionModel model = new ProjectionModel();
model.ProjectList = new SelectList(TimeSheetAPIHelperService.CostModelProject().Result, "ID", "Value");
model.OpportunityNumberList = new SelectList(TimeSheetAPIHelperService.CostModelProject().Result, "ID", "OpportunityNumber");
var listitem = TimeSheetAPIHelperService.CostModelProject().Result.Select(x => new ListItemViewModel()
{
Id = x.Id,
Value = x.Value
});
int opportunityId = listitem.FirstOrDefault().Id;
model.ActivityList = new SelectList(TimeSheetAPIHelperService.ProjectActivities(opportunityId).Result, "ID", "Value");
model.WarehouseList = new SelectList(ListItemService.Warehouses().Result, "ID", "Value");
model.ResourceList = new SelectList(ListItemService.Resources().Result, "ID", "Value");
model.SalesManagerList = new SelectList(ListItemService.SalesManagerList().Result, "ID", "Value");
model.ProjectmanagerList = new SelectList(ListItemService.ProjectManagerList().Result, "ID", "Value");
model.ServiceActivityList = new SelectList(ListItemService.ServiceActivitiesList().Result, "ID", "Value");
model.ProjectionList = ProjectionHelperService.ProjectionListItems().Result;
model.OpportunityList = ProjectionHelperService.OpportunityListItems().Result;
return(model);
}
public bool UpdateProjection(ProjectionModel projectionModel)
{
return _projectionRepository.UpdateProjection(projectionModel);
}
public ProjectionModel CreateProjection(ProjectionModel projectionModel)
{
return _projectionRepository.CreateProjection(projectionModel);
}
public ProjectionModelBuilder()
{
_model = new ProjectionModel(typeof(T));
}
public bool UpdateProjection(ProjectionModel projectionModel)
{
return(_projectionService.UpdateProjection(projectionModel));
}
public ProjectionModel CreateProjection(ProjectionModel projectionModel)
{
return(_projectionService.CreateProjection(projectionModel));
}
public BaseModel ParseTokens(IList <string> tokens)
{
var model = new ProjectionModel
{
ProjectedProperties = new List <string>()
};
bool fromKeywordParsed = false, whereKeywordParsed = false;
tokens.RemoveAt(0);
while (tokens.Count > 0)
{
var token = tokens[0];
if (!fromKeywordParsed && string.Equals(token, Keywords.From.ToString(), StringComparison.OrdinalIgnoreCase))
{
if (!model.ProjectAllProperties && !model.ProjectedProperties.Any())
{
throw new ParsingException("Projection Not Provided");
}
fromKeywordParsed = true;
tokens.RemoveAt(0);
continue;
}
if (fromKeywordParsed && !whereKeywordParsed && string.Equals(token, Keywords.Where.ToString(), StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrWhiteSpace(model.EntityName))
{
throw new ParsingException("Entity Name Not Provided");
}
whereKeywordParsed = true;
tokens.RemoveAt(0);
if (!tokens.Any())
{
throw new ParsingException("Where Condition Not Provided");
}
continue;
}
if (!fromKeywordParsed)
{
if (token == "*")
{
model.ProjectAllProperties = true;
}
else
{
if (model.ProjectAllProperties)
{
throw new ParsingException("Cannot Project Properties Alongside the * Operator");
}
model.ProjectedProperties.Add(token.Split('.').Last());
}
}
if (fromKeywordParsed && !whereKeywordParsed)
{
model.EntityName = token;
}
if (fromKeywordParsed && whereKeywordParsed)
{
model.Query = token;
}
tokens.RemoveAt(0);
}
return(model);
}
