// UpdateManyRoleProfiles allows many role profiles to be added at the
// same time
func UpdateManyRoleProfiles(
	siteID int64,
	roleID int64,
	ems []RoleProfileType,
) (
	int,
	error,
) {

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	for _, m := range ems {
		status, err := m.insert(tx, siteID, roleID)
		if err != nil {
			return status, err
		}
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	go PurgeCache(h.ItemTypes[h.ItemTypeRole], roleID)

	return http.StatusOK, nil
}
Example #2
0
// UpdateLastNotified updates a watcher according to the last time that watcher
// triggered a notification. The purpose is to record any contact so that we
// can avoid multiple notifications for a given item
func (m *WatcherType) UpdateLastNotified() (int, error) {

	tx, err := h.GetTransaction()
	if err != nil {
		glog.Error(err)
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
UPDATE watchers
   SET last_notified = NOW()
 WHERE watcher_id = $1`,
		m.ID,
	)
	if err != nil {
		glog.Error(err)
		tx.Rollback()
		return http.StatusInternalServerError, err
	}

	err = tx.Commit()
	if err != nil {
		glog.Error(err)
		return http.StatusInternalServerError, err
	}

	PurgeCache(h.ItemTypes[h.ItemTypeWatcher], m.ID)

	return http.StatusOK, nil
}
// Update saves a single participant
func (m *HuddleParticipantType) Update(
	siteID int64,
	huddleID int64,
) (
	int,
	error,
) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	status, err := m.insert(tx, siteID, huddleID)
	if err != nil {
		return status, err
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil
}
Example #4
0
// Delete removes an ignore
func (m *IgnoreType) Delete() (int, error) {
	status, err := m.Validate()
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	// Lack of error checking, it can only fail if it has been deleted already
	// and our answer "OK" remains the same if it exists after this action.
	tx.Exec(`--Delete Ignore
DELETE
  FROM ignores
 WHERE profile_id = $1
   AND item_type_id = $2
   AND item_id = $3`,
		m.ProfileID,
		m.ItemTypeID,
		m.ItemID,
	)
	if err == nil {
		tx.Commit()
	}

	return http.StatusOK, nil
}
// Delete removes an update option record for a specific user. Generally this
// will be unnecessary unless a user needs to clear their preferences completely
// and return to the defaults.
func (m *UpdateOptionType) Delete() (int, error) {

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
DELETE FROM update_options
 WHERE profile_id = $1
   AND update_type_id = $2`,
		m.ProfileID,
		m.UpdateTypeID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Delete failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil

}
Example #6
0
// UpdateManyAttributes updates many attributes at once
func UpdateManyAttributes(
	itemTypeID int64,
	itemID int64,
	ems []AttributeType,
) (
	int,
	error,
) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	for _, m := range ems {
		status, err := m.upsert(tx, itemTypeID, itemID)
		if err != nil {
			return status, err
		}
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil
}
Example #7
0
// Delete removes a microcosm from the database
func (m *MicrocosmType) Delete() (int, error) {

	// Delete resource
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`-- Delete Microcosm
UPDATE microcosms
   SET is_deleted = true
 WHERE microcosm_id = $1`,
		m.ID,
	)
	if err != nil {
		tx.Rollback()
		return http.StatusInternalServerError,
			fmt.Errorf("Delete failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeMicrocosm], m.ID)

	return http.StatusOK, nil
}
// UpdateManyHuddleParticipants saves many participants
func UpdateManyHuddleParticipants(
	siteID int64,
	huddleID int64,
	ems []HuddleParticipantType,
) (
	int,
	error,
) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	for _, m := range ems {
		status, err := m.insert(tx, siteID, huddleID)
		if err != nil {
			return status, err
		}
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf(fmt.Sprintf("Transaction failed: %+v", err))
	}

	go PurgeCache(h.ItemTypes[h.ItemTypeHuddle], huddleID)

	return http.StatusOK, nil
}
Example #9
0
// Delete removes a participant from a huddle
func (m *HuddleType) Delete(siteID int64, profileID int64) (int, error) {
	// Synonym for removing participant. If all participants are removed then
	// this will physically delete the huddle
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
DELETE FROM huddle_profiles
 WHERE huddle_id = $1
   AND profile_id = $2`,
		m.ID,
		profileID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Delete failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeHuddle], m.ID)

	return http.StatusOK, nil
}
Example #10
0
// Update saves the changes to an attachment
func (m *AttachmentType) Update() (int, error) {
	tx, err := h.GetTransaction()
	if err != nil {
		glog.Errorf("h.GetTransaction() %+v", err)
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
UPDATE attachments
   SET created = $1
 WHERE attachment_id = $2`,
		m.Created,
		m.AttachmentID,
	)
	if err != nil {
		glog.Errorf("tx.Exec(%v, %d) %+v", m.Created, m.AttachmentID, err)
		return http.StatusInternalServerError,
			fmt.Errorf("Attachment update failed")
	}

	err = tx.Commit()
	if err != nil {
		glog.Errorf("tx.Commit() %+v", err)
		return http.StatusInternalServerError, fmt.Errorf("Transaction failed")
	}

	return http.StatusOK, nil
}
Example #11
0
// DeleteMenu removes the entire menu
func DeleteMenu(siteID int64) (int, error) {
	tx, err := h.GetTransaction()
	if err != nil {
		glog.Errorf("h.GetTransaction() %+v", err)
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
DELETE FROM menus
 WHERE site_id = $1`,
		siteID,
	)
	if err != nil {
		glog.Errorf("stmt1.Exec(%d) %+v", siteID, err)
		return http.StatusInternalServerError,
			fmt.Errorf("Failed to delete existing menu")
	}

	err = tx.Commit()
	if err != nil {
		glog.Errorf("tx.Commit() %+v", err)
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed")
	}

	go PurgeCache(h.ItemTypes[h.ItemTypeSite], siteID)

	return http.StatusOK, nil
}
Example #12
0
// Update saves the ignore to the database
func (m *IgnoreType) Update() (int, error) {
	status, err := m.Validate()
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	// Lack of error checking, it can only fail if it has been inserted already
	// and our answer "OK" remains the same if it exists after this action.
	tx.Exec(`--Create Ignore
INSERT INTO ignores (
    profile_id, item_type_id, item_id
) VALUES (
    $1, $2, $3
)`,
		m.ProfileID,
		m.ItemTypeID,
		m.ItemID,
	)
	if err == nil {
		tx.Commit()
	}

	return http.StatusOK, nil
}
Example #13
0
// Delete nukes an event
func (m *EventType) Delete() (int, error) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
UPDATE events
   SET is_deleted = true
      ,is_visible = false
 WHERE event_id = $1`,
		m.ID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Delete failed: %v", err.Error())
	}

	err = DecrementMicrocosmItemCount(tx, m.MicrocosmID)
	if err != nil {
		return http.StatusInternalServerError, err
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeEvent], m.ID)
	PurgeCache(h.ItemTypes[h.ItemTypeMicrocosm], m.MicrocosmID)

	return http.StatusOK, nil
}
Example #14
0
// Insert creates the watcher
func (m *WatcherType) insert(imported bool) (int, error) {

	status, err := m.validate(imported)
	if err != nil {
		glog.Error(err)
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		glog.Error(err)
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	var insertID int64
	err = tx.QueryRow(`
INSERT INTO watchers (
    profile_id
   ,item_type_id
   ,item_id
   ,send_email
   ,send_sms
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5
) RETURNING watcher_id`,
		m.ProfileID,
		m.ItemTypeID,
		m.ItemID,
		m.SendEmail,
		m.SendSMS,
	).Scan(
		&insertID,
	)
	if err != nil {
		glog.Error(err)
		return http.StatusInternalServerError,
			fmt.Errorf("Error inserting data and returning ID: %+v", err)
	}
	m.ID = insertID

	err = tx.Commit()
	if err != nil {
		glog.Error(err)
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeWatcher], m.ID)

	return http.StatusOK, nil
}
// Insert creates a communication option to the database
func (m *UpdateOptionType) Insert() (int, error) {

	status, err := m.Validate()
	if err != nil {
		return status, err
	}

	// Check that a corresponding profile_options record exists,
	// otherwise profile_id constraint will fail.
	// TODO(lewi): check receive_email doesn't contradict
	// profile_options.email_updates
	_, status, err = GetProfileOptions(m.ProfileID)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Insert of update preference failed: %v", err.Error())
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
INSERT INTO update_options (
    profile_id
   ,update_type_id
   ,send_email
   ,send_sms
) VALUES (
    $1,
    $2,
    $3,
    $4
)`,
		m.ProfileID,
		m.UpdateTypeID,
		m.SendEmail,
		m.SendSMS,
	)
	if err != nil {
		tx.Rollback()
		return http.StatusInternalServerError,
			fmt.Errorf("Insert of update option failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil

}
func (m *ConversationType) insert(siteID int64, profileID int64) (int, error) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	var insertID int64
	err = tx.QueryRow(`--Create Conversation
INSERT INTO conversations (
    microcosm_id, title, created, created_by, view_count,
    is_deleted, is_moderated, is_open, is_sticky
) VALUES (
    $1, $2, $3, $4, $5,
    $6, $7, $8, $9
) RETURNING conversation_id`,
		m.MicrocosmID,
		m.Title,
		m.Meta.Created,
		m.Meta.CreatedByID,
		m.ViewCount,

		m.Meta.Flags.Deleted,
		m.Meta.Flags.Moderated,
		m.Meta.Flags.Open,
		m.Meta.Flags.Sticky,
	).Scan(
		&insertID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf(
				"Error inserting data and returning ID: %v",
				err.Error(),
			)
	}

	m.ID = insertID

	err = IncrementMicrocosmItemCount(tx, m.MicrocosmID)
	if err != nil {
		return http.StatusInternalServerError, err
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeConversation], m.ID)
	PurgeCache(h.ItemTypes[h.ItemTypeMicrocosm], m.MicrocosmID)

	return http.StatusOK, nil
}
Example #17
0
// Update saves changes to to a file
func (f *FileMetadataType) Update() (int, error) {
	status, err := f.Validate()
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
UPDATE attachment_meta
   SET created = $1
      ,file_size = $2
      ,file_sha1 = $3
      ,mime_type = $4
      ,width = $5
      ,height = $6
      ,thumbnail_width = $7
      ,thumbnail_height = $8
      ,attach_count = $9
      ,file_name = $10
      ,file_ext = $11
 WHERE attachment_meta_id = $12`,
		f.Created,
		f.FileSize,
		f.FileHash,
		f.MimeType,
		f.Width,
		f.Height,
		f.ThumbnailWidth,
		f.ThumbnailHeight,
		f.AttachCount,
		f.FileName,
		f.FileExt,
		f.AttachmentMetaID,
	)
	if err != nil {
		tx.Rollback()
		return http.StatusInternalServerError,
			fmt.Errorf("Could not update attachment metadata: %+v", err)
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %+v", err)
	}

	return http.StatusOK, nil
}
Example #18
0
// Update saves the current version of the profile to the database
func (m *ProfileType) Update() (int, error) {

	status, err := m.Validate(true)
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Could not start transaction: %v", err.Error())
	}
	defer tx.Rollback()

	_, err = tx.Exec(`--Update Profile
UPDATE profiles
   SET profile_name = $2
      ,gender = $3
      ,is_visible = $4
      ,style_id = $5
      ,item_count = $6
      ,comment_count = $7
      ,last_active = $8
      ,avatar_url = $9
      ,avatar_id = $10
 WHERE profile_id = $1`,
		m.ID,
		m.ProfileName,
		m.GenderNullable,
		m.Visible,
		m.StyleID,
		m.ItemCount,
		m.CommentCount,
		m.LastActive,
		m.AvatarURLNullable,
		m.AvatarIDNullable,
	)
	if err != nil {
		tx.Rollback()
		return http.StatusInternalServerError,
			fmt.Errorf("Update of profile failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeProfile], m.ID)

	return http.StatusOK, nil
}
// Insert saves the criterion to the database
func (m *RoleCriterionType) Insert(roleID int64) (int, error) {

	status, err := m.Validate(false)
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	var insertID int64
	err = tx.QueryRow(`
INSERT INTO criteria (
       role_id, or_group, profile_column, key, type,
       predicate, value
) VALUES (
       $1, $2, $3, $4, $5,
       $6, $7
) RETURNING criteria_id`,
		roleID,
		m.OrGroup,
		m.ProfileColumnNullable,
		m.AttrKeyNullable,
		m.Type,

		m.Predicate,
		m.ValueString,
	).Scan(
		&insertID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Error executing insert: %v", err.Error())
	}
	m.ID = insertID

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	go PurgeCache(h.ItemTypes[h.ItemTypeRole], roleID)

	return http.StatusOK, nil
}
Example #20
0
// Update saves changes to the microcosm
func (m *MicrocosmType) Update() (int, error) {

	status, err := m.Validate(true, false)
	if err != nil {
		return status, err
	}

	// Update resource
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`-- Update Microcosm
UPDATE microcosms
   SET site_id = $2,
       visibility = $3,
       title = $4,
       description = $5,
       edited = $6,
       edited_by = $7,
       edit_reason = $8
 WHERE microcosm_id = $1`,
		m.ID,
		m.SiteID,
		m.Visibility,
		m.Title,
		m.Description,
		m.Meta.EditedNullable,
		m.Meta.EditedByNullable,
		m.Meta.EditReason,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Update failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeMicrocosm], m.ID)

	return http.StatusOK, nil
}
Example #21
0
// UpdateUnreadHuddleCount updates the unread huddle count
func UpdateUnreadHuddleCount(profileID int64) {
	tx, err := h.GetTransaction()
	if err != nil {
		glog.Error(err)
		return
	}
	defer tx.Rollback()

	updateUnreadHuddleCount(tx, profileID)

	err = tx.Commit()
	if err != nil {
		glog.Error(err)
		return
	}
}
// Update saves changes to the criterion to the database
func (m *RoleCriterionType) Update(roleID int64) (int, error) {

	status, err := m.Validate(true)
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
UPDATE criteria
   SET or_group = $2
      ,profile_column = $3
      ,key = $4
      ,type = $5
      ,predicate = $6
      ,value = $7
 WHERE criteria_id = $1`,
		m.ID,
		m.OrGroup,
		m.ProfileColumnNullable,
		m.AttrKeyNullable,
		m.Type,

		m.Predicate,
		m.ValueString,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Error executing insert: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	go PurgeCache(h.ItemTypes[h.ItemTypeRole], roleID)

	return http.StatusOK, nil
}
Example #23
0
// Insert creates a user
func (m *UserType) Insert() (int, error) {

	status, err := m.Validate(false)
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Could not start transaction: %v", err.Error())
	}

	defer tx.Rollback()

	var insertID int64
	// TODO(buro9): language constraints, password flow
	err = tx.QueryRow(`
INSERT INTO users (
    email, created, language, is_banned, password,
    password_date
) VALUES (
    $1, NOW(), $2, false, $3,
    NOW()
) RETURNING user_id`,
		m.Email,
		m.Language,
		m.Password,
	).Scan(
		&insertID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Error inserting data and returning ID: %+v", err)
	}
	m.ID = insertID

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil
}
// Update updates a conversation
func (m *ConversationType) Update(siteID int64, profileID int64) (int, error) {

	status, err := m.Validate(siteID, profileID, true, false)
	if err != nil {
		return status, err
	}

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`--Update Conversation
UPDATE conversations
   SET microcosm_id = $2,
       title = $3,
       edited = $4,
       edited_by = $5,
       edit_reason = $6
 WHERE conversation_id = $1`,
		m.ID,
		m.MicrocosmID,
		m.Title,
		m.Meta.EditedNullable,
		m.Meta.EditedByNullable,
		m.Meta.EditReason,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Update failed: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeConversation], m.ID)
	PurgeCache(h.ItemTypes[h.ItemTypeMicrocosm], m.MicrocosmID)

	return http.StatusOK, nil
}
Example #25
0
// insert saves the microcosm to the database
func (m *MicrocosmType) insert() (int, error) {

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	var insertID int64
	err = tx.QueryRow(`-- Create Microcosm
INSERT INTO microcosms (
    site_id, visibility, title, description, created,
    created_by, owned_by
) VALUES (
    $1, $2, $3, $4, $5,
    $6, $7
) RETURNING microcosm_id`,
		m.SiteID,
		m.Visibility,
		m.Title,
		m.Description,
		m.Meta.Created,
		m.Meta.CreatedByID,
		m.OwnedByID,
	).Scan(
		&insertID,
	)
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Error inserting data and returning ID: %+v", err)
	}
	m.ID = insertID

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	PurgeCache(h.ItemTypes[h.ItemTypeMicrocosm], m.ID)

	return http.StatusOK, nil
}
Example #26
0
// DeleteManyAttributes removes many attributes
func DeleteManyAttributes(
	itemTypeID int64,
	itemID int64,
	ms []AttributeType,
) (
	int,
	error,
) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	for _, m := range ms {
		var (
			attributeID int64
			status      int
		)

		if m.ID > 0 {
			attributeID = m.ID
		} else {
			attributeID, status, err = GetAttributeID(itemTypeID, itemID, m.Key)
			if err != nil {
				return status, err
			}
		}

		status, err := m.delete(tx, attributeID)
		if err != nil {
			return status, err
		}
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil
}
Example #27
0
// Delete removes an attendee
func (m *AttendeeType) Delete(siteID int64) (int, error) {
	event, status, err := GetEvent(siteID, m.EventID, 0)
	if err != nil {
		glog.Errorf("GetEvent(%d, %d, 0) %+v", siteID, m.EventID, err)
		return status, err
	}

	// Connect to DB
	tx, err := h.GetTransaction()
	if err != nil {
		glog.Errorf("h.GetTransaction() %+v", err)
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	_, err = tx.Exec(`
DELETE FROM attendees
 WHERE attendee_id = $1`,
		m.ID,
	)
	if err != nil {
		glog.Errorf("tx.Exec(%d) %+v", m.ID, err)
		return http.StatusInternalServerError, fmt.Errorf("Delete failed")
	}

	status, err = event.UpdateAttendees(tx)
	if err != nil {
		glog.Errorf("event.UpdateAttendees(tx) %+v", err)
		return status, err
	}

	err = tx.Commit()
	if err != nil {
		glog.Errorf("tx.Commit() %+v", err)
		return http.StatusInternalServerError, fmt.Errorf("Transaction failed")
	}

	go PurgeCache(h.ItemTypes[h.ItemTypeAttendee], m.ID)
	go PurgeCache(h.ItemTypes[h.ItemTypeEvent], m.EventID)

	return http.StatusOK, nil
}
Example #28
0
// Delete removes a single attribute
func (m *AttributeType) Delete() (int, error) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	status, err := m.delete(tx, m.ID)
	if err != nil {
		return status, err
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil
}
Example #29
0
// Update updates a single attribute
func (m *AttributeType) Update(itemTypeID int64, itemID int64) (int, error) {
	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError, err
	}
	defer tx.Rollback()

	status, err := m.upsert(tx, itemTypeID, itemID)
	if err != nil {
		return status, err
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	return http.StatusOK, nil
}
// Update saves the updated options for a profile
func (m *ProfileOptionType) Update() (int, error) {

	tx, err := h.GetTransaction()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Could not start transaction: %v", err.Error())
	}

	defer tx.Rollback()

	_, err = tx.Exec(`
UPDATE profile_options
    SET show_dob_year = $2
    ,show_dob_date = $3
    ,send_email = $4
    ,send_sms = $5
    ,is_discouraged = $6
WHERE profile_id = $1`,
		m.ProfileID,
		m.ShowDOBYear,
		m.ShowDOB,
		m.SendEMail,
		m.SendSMS,
		m.IsDiscouraged,
	)
	if err != nil {
		tx.Rollback()
		return http.StatusInternalServerError,
			fmt.Errorf("Error inserting data: %v", err.Error())
	}

	err = tx.Commit()
	if err != nil {
		return http.StatusInternalServerError,
			fmt.Errorf("Transaction failed: %v", err.Error())
	}

	go PurgeCacheByScope(c.CacheOptions, h.ItemTypes[h.ItemTypeProfile], m.ProfileID)

	return http.StatusOK, nil
}