[ID-85]Webtools fixes

core/application.go

@@ -55,6 +55,7 @@ type Application struct {
 	storage Storage
 
 	eventsBBAdapter EventsBBAdapter
+	imageAdapter    ImageAdapter
 
 	//events logic
 	eventsLogic eventsLogic
@@ -92,9 +93,10 @@ func (a *Application) GetEnvConfigs() (*model.EnvConfigData, error) {
 func NewApplication(version string, build string,
 	storage Storage,
 	eventsBBAdapter EventsBBAdapter,
+	imageAdapter ImageAdapter,
 	appntAdapters map[string]Appointments,
 	logger *logs.Logger) *Application {
-	application := Application{version: version, build: build, storage: storage, eventsBBAdapter: eventsBBAdapter, logger: logger, AppointmentAdapters: appntAdapters}
+	application := Application{version: version, build: build, storage: storage, eventsBBAdapter: eventsBBAdapter, imageAdapter: imageAdapter, logger: logger, AppointmentAdapters: appntAdapters}
 
 	//add the drivers ports/interfaces
 	application.Default = newAppDefault(&application)

core/interfaces.go

@@ -136,6 +136,9 @@ type Storage interface {
 	FindWebtoolsBlacklistData() ([]model.WebToolsItem, error)
 	AddWebtoolsBlacklistData(dataSourceIDs []string, dataCalendarIDs []string) error
 	RemoveWebtoolsBlacklistData(dataSourceIDs []string, dataCalendarIDs []string) error
+
+	FindImageItems() ([]model.ContentImagesURL, error)
+	InsertImageItem(items model.ContentImagesURL) error
 }
 
 // StorageListener represents storage listener
@@ -187,3 +190,8 @@ type SuccessTeam interface {
 	GetPrimaryCareProvider(uin string, accesstoken string, conf *model.EnvConfigData) (*[]model.SuccessTeamMember, int, error)
 	GetAcademicAdvisors(uin string, calendars *[]model.UnitCalendar, accesstoken string, conf *model.EnvConfigData) (*[]model.SuccessTeamMember, int, error)
 }
+
+// ImageAdapter  is used to precess images
+type ImageAdapter interface {
+	ProcessImage(item model.WebToolsEvent) (*model.ContentImagesURL, error)
+}

core/logic_events.go

@@ -247,6 +247,7 @@ func (e eventsLogic) processWebToolsEvents() {
 		e.logger.Errorf("error on loading web tools events - %s", err)
 		return
 	}
+
 	webToolsCount := len(allWebToolsEvents)
 	if webToolsCount == 0 {
 		e.logger.Error("web tools are nil")
@@ -255,6 +256,13 @@ func (e eventsLogic) processWebToolsEvents() {
 
 	e.logger.Infof("we loaded %d web tools events", webToolsCount)
 
+	//process the images before the main processing
+	imagesData, err := e.processImages(allWebToolsEvents)
+	if err != nil {
+		e.logger.Errorf("error on processing images - %s", err)
+		return
+	}
+
 	now := time.Now()
 
 	//in transaction
@@ -296,7 +304,7 @@ func (e eventsLogic) processWebToolsEvents() {
 			//prepare the id
 			id := e.prepareID(wt.EventID, existingLegacyIdsMap)
 
-			le := e.constructLegacyEvent(wt, id, now)
+			le := e.constructLegacyEvent(wt, id, now, imagesData)
 			newLegacyEvents = append(newLegacyEvents, le)
 		}
 
@@ -317,6 +325,99 @@ func (e eventsLogic) processWebToolsEvents() {
 	}
 }
 
+func (e eventsLogic) processImages(allWebtoolsEvents []model.WebToolsEvent) ([]model.ContentImagesURL, error) {
+	//get the events for images processing
+	forProcessingEvents, err := e.getEventsForImagesProcessing(allWebtoolsEvents)
+	if err != nil {
+		return nil, err
+	}
+
+	e.logger.Infof("there are %d events for images processing", len(forProcessingEvents))
+
+	//get the events which are not processed
+	notProccesed, err := e.getNotProcessedEvents(forProcessingEvents)
+	if err != nil {
+		return nil, err
+	}
+
+	e.logger.Infof("there are %d events to be processed as not proccesed", len(notProccesed))
+
+	//process the images which have not been processed
+	err = e.applyProcessImages(notProccesed)
+	if err != nil {
+		e.logger.Error("Error on processing images")
+		return nil, err
+	}
+
+	//as we already ahve processed all iages just return this dtaa to be used
+	imagesData, err := e.app.storage.FindImageItems()
+	if err != nil {
+		return nil, err
+	}
+
+	return imagesData, nil
+}
+
+func (e eventsLogic) getEventsForImagesProcessing(allWebtoolsEvents []model.WebToolsEvent) ([]model.WebToolsEvent, error) {
+	res := []model.WebToolsEvent{}
+	for _, w := range allWebtoolsEvents {
+		if w.LargeImageUploaded == "true" {
+			res = append(res, w)
+		}
+
+	}
+	return res, nil
+}
+
+func (e eventsLogic) getNotProcessedEvents(eventsForProcessing []model.WebToolsEvent) ([]model.WebToolsEvent, error) {
+	allProcessed, err := e.app.storage.FindImageItems()
+	if err != nil {
+		return nil, err
+	}
+
+	processedMap := make(map[string]bool) // map to keep track of processed events
+	for _, item := range allProcessed {
+		processedMap[item.ID] = true
+	}
+
+	var notProcessedEvents []model.WebToolsEvent
+	for _, event := range eventsForProcessing {
+		if _, processed := processedMap[event.EventID]; !processed {
+			notProcessedEvents = append(notProcessedEvents, event)
+		}
+	}
+
+	return notProcessedEvents, nil
+}
+
+func (e eventsLogic) applyProcessImages(item []model.WebToolsEvent) error {
+	i := 0
+	for _, w := range item {
+
+		//process image
+		res, err := e.app.imageAdapter.ProcessImage(w)
+		if err != nil {
+			return err
+		}
+
+		if res == nil {
+			continue
+		}
+
+		//mark as processed
+		err = e.app.storage.InsertImageItem(*res)
+		if err != nil {
+			return err
+		}
+
+		e.logger.Infof("%d - %s image was processed: %s", i, res.ID, res.ImageURL)
+
+		i++
+	}
+	return nil
+
+}
+
 // ignore or modify webtools events
 func (e eventsLogic) modifyWebtoolsEventsList(allWebtoolsEvents []model.WebToolsEvent) ([]model.WebToolsEvent, error) {
 	modifiedList := []model.WebToolsEvent{}
@@ -432,7 +533,7 @@ func (e eventsLogic) loadAllWebToolsEvents() ([]model.WebToolsEvent, error) {
 	return allWebToolsEvents, nil
 }
 
-func (e eventsLogic) constructLegacyEvent(g model.WebToolsEvent, id string, now time.Time) model.LegacyEventItem {
+func (e eventsLogic) constructLegacyEvent(g model.WebToolsEvent, id string, now time.Time, imagesData []model.ContentImagesURL) model.LegacyEventItem {
 	syncProcessSource := "webtools-direct"
 
 	createdBy := g.CreatedBy
@@ -555,14 +656,26 @@ func (e eventsLogic) constructLegacyEvent(g model.WebToolsEvent, id string, now
 	}
 	//end target audience
 
+	//image url
+	imageURL := e.getImageURL(g.EventID, imagesData)
+
 	return model.LegacyEventItem{SyncProcessSource: syncProcessSource, SyncDate: now,
 		Item: model.LegacyEvent{ID: id, Category: g.EventType, CreatedBy: createdBy, OriginatingCalendarID: g.OriginatingCalendarID, IsVirtial: isVirtual,
 			DataModified: modifiedDate, DateCreated: createdDate,
 			Sponsor: g.Sponsor, Title: g.Title, CalendarID: g.CalendarID, SourceID: "0", AllDay: allDay, IsEventFree: costFree, Cost: g.Cost, LongDescription: g.Description,
 			TitleURL: g.TitleURL, RegistrationURL: g.RegistrationURL, RecurringFlag: Recurrence, IcalURL: icalURL, OutlookURL: outlookURL,
 			RecurrenceID: recurrenceID, Location: &location, Contacts: contatsLegacy,
 			DataSourceEventID: g.EventID, StartDate: startDateStr, EndDate: endDateStr,
-			Tags: tags, TargetAudience: targetAudience}}
+			Tags: tags, TargetAudience: targetAudience, ImageURL: imageURL}}
+}
+
+func (e eventsLogic) getImageURL(eventID string, imageData []model.ContentImagesURL) *string {
+	for _, image := range imageData {
+		if image.ID == eventID {
+			return &image.ImageURL
+		}
+	}
+	return nil
 }
 
 func (e eventsLogic) formatDate(wtDate string) string {

core/model/images.go

@@ -0,0 +1,31 @@
+// Copyright 2022 Board of Trustees of the University of Illinois.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package model
+
+// ContentImagesURL is used to keep the imageURL from ContentBB
+type ContentImagesURL struct {
+	ID       string `json:"id" bson:"_id"`
+	ImageURL string `json:"imageURL" bson:"imageURL"`
+}
+
+// ImageData is used to keep the the image thata from webtools
+type ImageData struct {
+	ImageData []byte `json:"image_data"`
+	Height    int    `json:"height"`
+	Width     int    `json:"width"`
+	Quality   int    `json:"quality"`
+	Path      string `json:"path"`
+	FileName  string `json:"fileName"`
+}